001package org.hl7.fhir.r5.formats;
002
003
004// generated
005
006/*
007 * #%L
008 * org.hl7.fhir.r5
009 * %%
010 * Copyright (C) 2014 - 2019 Health Level 7
011 * %%
012 * Licensed under the Apache License, Version 2.0 (the \"License\");
013 * you may not use this file except in compliance with the License.
014 * You may obtain a copy of the License at
015 * 
016 *      http://www.apache.org/licenses/LICENSE-2.0
017 * 
018 * Unless required by applicable law or agreed to in writing, software
019 * distributed under the License is distributed on an \"AS IS\" BASIS,
020 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
021 * See the License for the specific language governing permissions and
022 * limitations under the License.
023 * #L%
024 */
025
026/*
027  Copyright (c) 2011+, HL7, Inc.
028  All rights reserved.
029  
030  Redistribution and use in source and binary forms, with or without modification, \
031  are permitted provided that the following conditions are met:
032  
033   * Redistributions of source code must retain the above copyright notice, this \
034     list of conditions and the following disclaimer.
035   * Redistributions in binary form must reproduce the above copyright notice, \
036     this list of conditions and the following disclaimer in the documentation \
037     and/or other materials provided with the distribution.
038   * Neither the name of HL7 nor the names of its contributors may be used to 
039     endorse or promote products derived from this software without specific 
040     prior written permission.
041  
042  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
043  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
044  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
045  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
046  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
047  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
048  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
049  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
050  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
051  POSSIBILITY OF SUCH DAMAGE.
052  */
053
054// Generated on Tue, Dec 31, 2019 12:12+1100 for FHIR vcurrent
055
056
057
058import org.hl7.fhir.r5.model.*;
059import org.hl7.fhir.utilities.Utilities;
060import org.hl7.fhir.exceptions.FHIRFormatError;
061import org.hl7.fhir.exceptions.FHIRException;
062import org.hl7.fhir.r5.utils.formats.Turtle.Complex;
063import java.io.IOException;
064
065public class RdfParser extends RdfParserBase {
066
067  public RdfParser() {
068    super();
069  }
070
071  public RdfParser(boolean allowUnknownContent) {
072    super();
073    setAllowUnknownContent(allowUnknownContent);
074  }
075
076  private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) {
077    if (value == null)
078      return;
079    Complex t = parent.predicate("fhir:"+parentType+"."+name);
080    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
081    composeElement(t, parentType, name, value, index);
082    decorateCode(t, value);
083  }
084
085
086  protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) {
087    if (value == null)
088      return;
089    Complex t = parent.predicate("fhir:"+parentType+"."+name);
090    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
091    composeElement(t, parentType, name, value, index);
092  }
093
094  protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) {
095    if (value == null)
096      return;
097    Complex t = parent.predicate("fhir:"+parentType+"."+name);
098    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
099    composeElement(t, parentType, name, value, index);
100  }
101
102  protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) {
103    if (value == null)
104      return;
105    Complex t = parent.predicate("fhir:"+parentType+"."+name);
106    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
107    composeElement(t, parentType, name, value, index);
108    decorateCode(t, value);
109  }
110
111  protected void composeString(Complex parent, String parentType, String name, StringType value, int index) {
112    if (value == null)
113      return;
114    Complex t = parent.predicate("fhir:"+parentType+"."+name);
115    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
116    composeElement(t, parentType, name, value, index);
117  }
118
119  protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) {
120    if (value == null)
121      return;
122    Complex t = parent.predicate("fhir:"+parentType+"."+name);
123    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
124    composeElement(t, parentType, name, value, index);
125  }
126
127  protected void composeInteger64(Complex parent, String parentType, String name, Integer64Type value, int index) {
128    if (value == null)
129      return;
130    Complex t = parent.predicate("fhir:"+parentType+"."+name);
131    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
132    composeElement(t, parentType, name, value, index);
133  }
134
135  protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) {
136    if (value == null)
137      return;
138    Complex t = parent.predicate("fhir:"+parentType+"."+name);
139    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
140    composeElement(t, parentType, name, value, index);
141  }
142
143  protected void composeCanonical(Complex parent, String parentType, String name, CanonicalType value, int index) {
144    if (value == null)
145      return;
146    Complex t = parent.predicate("fhir:"+parentType+"."+name);
147    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
148    composeElement(t, parentType, name, value, index);
149  }
150
151  protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) {
152    if (value == null)
153      return;
154    Complex t = parent.predicate("fhir:"+parentType+"."+name);
155    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
156    composeElement(t, parentType, name, value, index);
157  }
158
159  protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) {
160    if (value == null)
161      return;
162    Complex t = parent.predicate("fhir:"+parentType+"."+name);
163    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
164    composeElement(t, parentType, name, value, index);
165  }
166
167  protected void composeUrl(Complex parent, String parentType, String name, UrlType value, int index) {
168    if (value == null)
169      return;
170    Complex t = parent.predicate("fhir:"+parentType+"."+name);
171    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
172    composeElement(t, parentType, name, value, index);
173  }
174
175  protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) {
176    if (value == null)
177      return;
178    Complex t = parent.predicate("fhir:"+parentType+"."+name);
179    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
180    composeElement(t, parentType, name, value, index);
181  }
182
183  protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) {
184    if (value == null)
185      return;
186    Complex t = parent.predicate("fhir:"+parentType+"."+name);
187    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
188    composeElement(t, parentType, name, value, index);
189  }
190
191  protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) {
192    if (value == null)
193      return;
194    Complex t = parent.predicate("fhir:"+parentType+"."+name);
195    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
196    composeElement(t, parentType, name, value, index);
197  }
198
199  protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) {
200    if (value == null)
201      return;
202    Complex t = parent.predicate("fhir:"+parentType+"."+name);
203    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
204    composeElement(t, parentType, name, value, index);
205  }
206
207  protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) {
208    if (value == null)
209      return;
210    Complex t = parent.predicate("fhir:"+parentType+"."+name);
211    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
212    composeElement(t, parentType, name, value, index);
213  }
214
215  protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) {
216    if (value == null)
217      return;
218    Complex t = parent.predicate("fhir:"+parentType+"."+name);
219    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
220    composeElement(t, parentType, name, value, index);
221  }
222
223  protected void composeId(Complex parent, String parentType, String name, IdType value, int index) {
224    if (value == null)
225      return;
226    Complex t = parent.predicate("fhir:"+parentType+"."+name);
227    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
228    composeElement(t, parentType, name, value, index);
229  }
230
231  protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) {
232    if (value == null)
233      return;
234    Complex t = parent.predicate("fhir:"+parentType+"."+name);
235    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
236    composeElement(t, parentType, name, value, index);
237  }
238
239  protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) {
240    if (value == null)
241      return;
242    Complex t = parent.predicate("fhir:"+parentType+"."+name);
243    t.predicate("fhir:value", ttlLiteral(value.asStringValue()));
244    composeElement(t, parentType, name, value, index);
245  }
246
247  protected void composeBackboneElement(Complex t, String parentType, String name, BackboneElement element, int index) {
248    composeElement(t, parentType, name, element, index);
249    for (int i = 0; i < element.getModifierExtension().size(); i++) {
250      composeExtension(t, "BackboneElement", "modifierExtension", element.getModifierExtension().get(i), i);
251    }
252  }
253
254  protected void composeBackboneType(Complex t, String parentType, String name, BackboneType element, int index) {
255    composeDataType(t, parentType, name, element, index);
256    for (int i = 0; i < element.getModifierExtension().size(); i++) {
257      composeExtension(t, "BackboneType", "modifierExtension", element.getModifierExtension().get(i), i);
258    }
259  }
260
261  protected void composeDataType(Complex t, String parentType, String name, DataType element, int index) {
262    composeElement(t, parentType, name, element, index);
263  }
264
265  protected void composeElement(Complex t, String parentType, String name, Element element, int index) {
266    composeBase(t, parentType, name, element, index);
267    if (element.hasIdElement()) {
268      composeString(t, "Element", "id", element.getIdElement(), -1);
269    }
270    for (int i = 0; i < element.getExtension().size(); i++) {
271      composeExtension(t, "Element", "extension", element.getExtension().get(i), i);
272    }
273  }
274
275  protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) {
276    if (element == null) 
277      return;
278    Complex t;
279    if (Utilities.noString(parentType))
280      t = parent;
281    else {
282      t = parent.predicate("fhir:"+parentType+'.'+name);
283    }
284    composeDataType(t, "Address", name, element, index);
285    if (element.hasUseElement()) {
286      composeEnum(t, "Address", "use", element.getUseElement(), -1);
287    }
288    if (element.hasTypeElement()) {
289      composeEnum(t, "Address", "type", element.getTypeElement(), -1);
290    }
291    if (element.hasTextElement()) {
292      composeString(t, "Address", "text", element.getTextElement(), -1);
293    }
294    for (int i = 0; i < element.getLine().size(); i++) {
295      composeString(t, "Address", "line", element.getLine().get(i), i);
296    }
297    if (element.hasCityElement()) {
298      composeString(t, "Address", "city", element.getCityElement(), -1);
299    }
300    if (element.hasDistrictElement()) {
301      composeString(t, "Address", "district", element.getDistrictElement(), -1);
302    }
303    if (element.hasStateElement()) {
304      composeString(t, "Address", "state", element.getStateElement(), -1);
305    }
306    if (element.hasPostalCodeElement()) {
307      composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1);
308    }
309    if (element.hasCountryElement()) {
310      composeString(t, "Address", "country", element.getCountryElement(), -1);
311    }
312    if (element.hasPeriod()) {
313      composePeriod(t, "Address", "period", element.getPeriod(), -1);
314    }
315  }
316
317  protected void composeAge(Complex parent, String parentType, String name, Age element, int index) {
318    if (element == null) 
319      return;
320    Complex t;
321    if (Utilities.noString(parentType))
322      t = parent;
323    else {
324      t = parent.predicate("fhir:"+parentType+'.'+name);
325    }
326    composeQuantity(t, "Age", name, element, index);
327  }
328
329  protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) {
330    if (element == null) 
331      return;
332    Complex t;
333    if (Utilities.noString(parentType))
334      t = parent;
335    else {
336      t = parent.predicate("fhir:"+parentType+'.'+name);
337    }
338    composeDataType(t, "Annotation", name, element, index);
339    if (element.hasAuthor()) {
340      composeType(t, "Annotation", "author", element.getAuthor(), -1);
341    }
342    if (element.hasTimeElement()) {
343      composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1);
344    }
345    if (element.hasTextElement()) {
346      composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1);
347    }
348  }
349
350  protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) {
351    if (element == null) 
352      return;
353    Complex t;
354    if (Utilities.noString(parentType))
355      t = parent;
356    else {
357      t = parent.predicate("fhir:"+parentType+'.'+name);
358    }
359    composeDataType(t, "Attachment", name, element, index);
360    if (element.hasContentTypeElement()) {
361      composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1);
362    }
363    if (element.hasLanguageElement()) {
364      composeCode(t, "Attachment", "language", element.getLanguageElement(), -1);
365    }
366    if (element.hasDataElement()) {
367      composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1);
368    }
369    if (element.hasUrlElement()) {
370      composeUrl(t, "Attachment", "url", element.getUrlElement(), -1);
371    }
372    if (element.hasSizeElement()) {
373      composeInteger64(t, "Attachment", "size", element.getSizeElement(), -1);
374    }
375    if (element.hasHashElement()) {
376      composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1);
377    }
378    if (element.hasTitleElement()) {
379      composeString(t, "Attachment", "title", element.getTitleElement(), -1);
380    }
381    if (element.hasCreationElement()) {
382      composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1);
383    }
384    if (element.hasHeightElement()) {
385      composePositiveInt(t, "Attachment", "height", element.getHeightElement(), -1);
386    }
387    if (element.hasWidthElement()) {
388      composePositiveInt(t, "Attachment", "width", element.getWidthElement(), -1);
389    }
390    if (element.hasFramesElement()) {
391      composePositiveInt(t, "Attachment", "frames", element.getFramesElement(), -1);
392    }
393    if (element.hasDurationElement()) {
394      composeDecimal(t, "Attachment", "duration", element.getDurationElement(), -1);
395    }
396    if (element.hasPagesElement()) {
397      composePositiveInt(t, "Attachment", "pages", element.getPagesElement(), -1);
398    }
399  }
400
401  protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) {
402    if (element == null) 
403      return;
404    Complex t;
405    if (Utilities.noString(parentType))
406      t = parent;
407    else {
408      t = parent.predicate("fhir:"+parentType+'.'+name);
409    }
410    composeDataType(t, "CodeableConcept", name, element, index);
411    decorateCodeableConcept(t, element);
412    for (int i = 0; i < element.getCoding().size(); i++) {
413      composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i);
414    }
415    if (element.hasTextElement()) {
416      composeString(t, "CodeableConcept", "text", element.getTextElement(), -1);
417    }
418  }
419
420  protected void composeCodeableReference(Complex parent, String parentType, String name, CodeableReference element, int index) {
421    if (element == null) 
422      return;
423    Complex t;
424    if (Utilities.noString(parentType))
425      t = parent;
426    else {
427      t = parent.predicate("fhir:"+parentType+'.'+name);
428    }
429    composeDataType(t, "CodeableReference", name, element, index);
430    if (element.hasConcept()) {
431      composeCodeableConcept(t, "CodeableReference", "concept", element.getConcept(), -1);
432    }
433    if (element.hasReference()) {
434      composeReference(t, "CodeableReference", "reference", element.getReference(), -1);
435    }
436  }
437
438  protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) {
439    if (element == null) 
440      return;
441    Complex t;
442    if (Utilities.noString(parentType))
443      t = parent;
444    else {
445      t = parent.predicate("fhir:"+parentType+'.'+name);
446    }
447    composeDataType(t, "Coding", name, element, index);
448    decorateCoding(t, element);
449    if (element.hasSystemElement()) {
450      composeUri(t, "Coding", "system", element.getSystemElement(), -1);
451    }
452    if (element.hasVersionElement()) {
453      composeString(t, "Coding", "version", element.getVersionElement(), -1);
454    }
455    if (element.hasCodeElement()) {
456      composeCode(t, "Coding", "code", element.getCodeElement(), -1);
457    }
458    if (element.hasDisplayElement()) {
459      composeString(t, "Coding", "display", element.getDisplayElement(), -1);
460    }
461    if (element.hasUserSelectedElement()) {
462      composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1);
463    }
464  }
465
466  protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) {
467    if (element == null) 
468      return;
469    Complex t;
470    if (Utilities.noString(parentType))
471      t = parent;
472    else {
473      t = parent.predicate("fhir:"+parentType+'.'+name);
474    }
475    composeDataType(t, "ContactDetail", name, element, index);
476    if (element.hasNameElement()) {
477      composeString(t, "ContactDetail", "name", element.getNameElement(), -1);
478    }
479    for (int i = 0; i < element.getTelecom().size(); i++) {
480      composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i);
481    }
482  }
483
484  protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) {
485    if (element == null) 
486      return;
487    Complex t;
488    if (Utilities.noString(parentType))
489      t = parent;
490    else {
491      t = parent.predicate("fhir:"+parentType+'.'+name);
492    }
493    composeDataType(t, "ContactPoint", name, element, index);
494    if (element.hasSystemElement()) {
495      composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1);
496    }
497    if (element.hasValueElement()) {
498      composeString(t, "ContactPoint", "value", element.getValueElement(), -1);
499    }
500    if (element.hasUseElement()) {
501      composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1);
502    }
503    if (element.hasRankElement()) {
504      composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1);
505    }
506    if (element.hasPeriod()) {
507      composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1);
508    }
509  }
510
511  protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) {
512    if (element == null) 
513      return;
514    Complex t;
515    if (Utilities.noString(parentType))
516      t = parent;
517    else {
518      t = parent.predicate("fhir:"+parentType+'.'+name);
519    }
520    composeDataType(t, "Contributor", name, element, index);
521    if (element.hasTypeElement()) {
522      composeEnum(t, "Contributor", "type", element.getTypeElement(), -1);
523    }
524    if (element.hasNameElement()) {
525      composeString(t, "Contributor", "name", element.getNameElement(), -1);
526    }
527    for (int i = 0; i < element.getContact().size(); i++) {
528      composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i);
529    }
530  }
531
532  protected void composeCount(Complex parent, String parentType, String name, Count element, int index) {
533    if (element == null) 
534      return;
535    Complex t;
536    if (Utilities.noString(parentType))
537      t = parent;
538    else {
539      t = parent.predicate("fhir:"+parentType+'.'+name);
540    }
541    composeQuantity(t, "Count", name, element, index);
542  }
543
544  protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) {
545    if (element == null) 
546      return;
547    Complex t;
548    if (Utilities.noString(parentType))
549      t = parent;
550    else {
551      t = parent.predicate("fhir:"+parentType+'.'+name);
552    }
553    composeDataType(t, "DataRequirement", name, element, index);
554    if (element.hasTypeElement()) {
555      composeEnum(t, "DataRequirement", "type", element.getTypeElement(), -1);
556    }
557    for (int i = 0; i < element.getProfile().size(); i++) {
558      composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i);
559    }
560    if (element.hasSubject()) {
561      composeType(t, "DataRequirement", "subject", element.getSubject(), -1);
562    }
563    for (int i = 0; i < element.getMustSupport().size(); i++) {
564      composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i);
565    }
566    for (int i = 0; i < element.getCodeFilter().size(); i++) {
567      composeDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i);
568    }
569    for (int i = 0; i < element.getDateFilter().size(); i++) {
570      composeDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i);
571    }
572    if (element.hasLimitElement()) {
573      composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1);
574    }
575    for (int i = 0; i < element.getSort().size(); i++) {
576      composeDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i);
577    }
578  }
579
580  protected void composeDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) {
581    if (element == null) 
582      return;
583    Complex t;
584    if (Utilities.noString(parentType))
585      t = parent;
586    else {
587      t = parent.predicate("fhir:"+parentType+'.'+name);
588    }
589    composeElement(t, "codeFilter", name, element, index);
590    if (element.hasPathElement()) {
591      composeString(t, "DataRequirementCodeFilterComponent", "path", element.getPathElement(), -1);
592    }
593    if (element.hasSearchParamElement()) {
594      composeString(t, "DataRequirementCodeFilterComponent", "searchParam", element.getSearchParamElement(), -1);
595    }
596    if (element.hasValueSetElement()) {
597      composeCanonical(t, "DataRequirementCodeFilterComponent", "valueSet", element.getValueSetElement(), -1);
598    }
599    for (int i = 0; i < element.getCode().size(); i++) {
600      composeCoding(t, "DataRequirementCodeFilterComponent", "code", element.getCode().get(i), i);
601    }
602  }
603
604  protected void composeDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) {
605    if (element == null) 
606      return;
607    Complex t;
608    if (Utilities.noString(parentType))
609      t = parent;
610    else {
611      t = parent.predicate("fhir:"+parentType+'.'+name);
612    }
613    composeElement(t, "dateFilter", name, element, index);
614    if (element.hasPathElement()) {
615      composeString(t, "DataRequirementDateFilterComponent", "path", element.getPathElement(), -1);
616    }
617    if (element.hasSearchParamElement()) {
618      composeString(t, "DataRequirementDateFilterComponent", "searchParam", element.getSearchParamElement(), -1);
619    }
620    if (element.hasValue()) {
621      composeType(t, "DataRequirementDateFilterComponent", "value", element.getValue(), -1);
622    }
623  }
624
625  protected void composeDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) {
626    if (element == null) 
627      return;
628    Complex t;
629    if (Utilities.noString(parentType))
630      t = parent;
631    else {
632      t = parent.predicate("fhir:"+parentType+'.'+name);
633    }
634    composeElement(t, "sort", name, element, index);
635    if (element.hasPathElement()) {
636      composeString(t, "DataRequirementSortComponent", "path", element.getPathElement(), -1);
637    }
638    if (element.hasDirectionElement()) {
639      composeEnum(t, "DataRequirementSortComponent", "direction", element.getDirectionElement(), -1);
640    }
641  }
642
643  protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) {
644    if (element == null) 
645      return;
646    Complex t;
647    if (Utilities.noString(parentType))
648      t = parent;
649    else {
650      t = parent.predicate("fhir:"+parentType+'.'+name);
651    }
652    composeQuantity(t, "Distance", name, element, index);
653  }
654
655  protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) {
656    if (element == null) 
657      return;
658    Complex t;
659    if (Utilities.noString(parentType))
660      t = parent;
661    else {
662      t = parent.predicate("fhir:"+parentType+'.'+name);
663    }
664    composeBackboneType(t, "Dosage", name, element, index);
665    if (element.hasSequenceElement()) {
666      composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1);
667    }
668    if (element.hasTextElement()) {
669      composeString(t, "Dosage", "text", element.getTextElement(), -1);
670    }
671    for (int i = 0; i < element.getAdditionalInstruction().size(); i++) {
672      composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i);
673    }
674    if (element.hasPatientInstructionElement()) {
675      composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1);
676    }
677    if (element.hasTiming()) {
678      composeTiming(t, "Dosage", "timing", element.getTiming(), -1);
679    }
680    if (element.hasAsNeeded()) {
681      composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1);
682    }
683    if (element.hasSite()) {
684      composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1);
685    }
686    if (element.hasRoute()) {
687      composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1);
688    }
689    if (element.hasMethod()) {
690      composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1);
691    }
692    for (int i = 0; i < element.getDoseAndRate().size(); i++) {
693      composeDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i);
694    }
695    if (element.hasMaxDosePerPeriod()) {
696      composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1);
697    }
698    if (element.hasMaxDosePerAdministration()) {
699      composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1);
700    }
701    if (element.hasMaxDosePerLifetime()) {
702      composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1);
703    }
704  }
705
706  protected void composeDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) {
707    if (element == null) 
708      return;
709    Complex t;
710    if (Utilities.noString(parentType))
711      t = parent;
712    else {
713      t = parent.predicate("fhir:"+parentType+'.'+name);
714    }
715    composeElement(t, "doseAndRate", name, element, index);
716    if (element.hasType()) {
717      composeCodeableConcept(t, "DosageDoseAndRateComponent", "type", element.getType(), -1);
718    }
719    if (element.hasDose()) {
720      composeType(t, "DosageDoseAndRateComponent", "dose", element.getDose(), -1);
721    }
722    if (element.hasRate()) {
723      composeType(t, "DosageDoseAndRateComponent", "rate", element.getRate(), -1);
724    }
725  }
726
727  protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) {
728    if (element == null) 
729      return;
730    Complex t;
731    if (Utilities.noString(parentType))
732      t = parent;
733    else {
734      t = parent.predicate("fhir:"+parentType+'.'+name);
735    }
736    composeQuantity(t, "Duration", name, element, index);
737  }
738
739  protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) {
740    if (element == null) 
741      return;
742    Complex t;
743    if (Utilities.noString(parentType))
744      t = parent;
745    else {
746      t = parent.predicate("fhir:"+parentType+'.'+name);
747    }
748    composeBackboneType(t, "ElementDefinition", name, element, index);
749    if (element.hasPathElement()) {
750      composeString(t, "ElementDefinition", "path", element.getPathElement(), -1);
751    }
752    for (int i = 0; i < element.getRepresentation().size(); i++) {
753      composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i);
754    }
755    if (element.hasSliceNameElement()) {
756      composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1);
757    }
758    if (element.hasSliceIsConstrainingElement()) {
759      composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1);
760    }
761    if (element.hasLabelElement()) {
762      composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1);
763    }
764    for (int i = 0; i < element.getCode().size(); i++) {
765      composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i);
766    }
767    if (element.hasSlicing()) {
768      composeElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1);
769    }
770    if (element.hasShortElement()) {
771      composeString(t, "ElementDefinition", "short", element.getShortElement(), -1);
772    }
773    if (element.hasDefinitionElement()) {
774      composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1);
775    }
776    if (element.hasCommentElement()) {
777      composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1);
778    }
779    if (element.hasRequirementsElement()) {
780      composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1);
781    }
782    for (int i = 0; i < element.getAlias().size(); i++) {
783      composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i);
784    }
785    if (element.hasMinElement()) {
786      composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1);
787    }
788    if (element.hasMaxElement()) {
789      composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1);
790    }
791    if (element.hasBase()) {
792      composeElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1);
793    }
794    if (element.hasContentReferenceElement()) {
795      composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1);
796    }
797    for (int i = 0; i < element.getType().size(); i++) {
798      composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i);
799    }
800    if (element.hasDefaultValue()) {
801      composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1);
802    }
803    if (element.hasMeaningWhenMissingElement()) {
804      composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1);
805    }
806    if (element.hasOrderMeaningElement()) {
807      composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1);
808    }
809    if (element.hasFixed()) {
810      composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1);
811    }
812    if (element.hasPattern()) {
813      composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1);
814    }
815    for (int i = 0; i < element.getExample().size(); i++) {
816      composeElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i);
817    }
818    if (element.hasMinValue()) {
819      composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1);
820    }
821    if (element.hasMaxValue()) {
822      composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1);
823    }
824    if (element.hasMaxLengthElement()) {
825      composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1);
826    }
827    for (int i = 0; i < element.getCondition().size(); i++) {
828      composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i);
829    }
830    for (int i = 0; i < element.getConstraint().size(); i++) {
831      composeElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i);
832    }
833    if (element.hasMustSupportElement()) {
834      composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1);
835    }
836    if (element.hasIsModifierElement()) {
837      composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1);
838    }
839    if (element.hasIsModifierReasonElement()) {
840      composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1);
841    }
842    if (element.hasIsSummaryElement()) {
843      composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1);
844    }
845    if (element.hasBinding()) {
846      composeElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1);
847    }
848    for (int i = 0; i < element.getMapping().size(); i++) {
849      composeElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i);
850    }
851  }
852
853  protected void composeElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent 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, "slicing", name, element, index);
863    for (int i = 0; i < element.getDiscriminator().size(); i++) {
864      composeElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinitionSlicingComponent", "discriminator", element.getDiscriminator().get(i), i);
865    }
866    if (element.hasDescriptionElement()) {
867      composeString(t, "ElementDefinitionSlicingComponent", "description", element.getDescriptionElement(), -1);
868    }
869    if (element.hasOrderedElement()) {
870      composeBoolean(t, "ElementDefinitionSlicingComponent", "ordered", element.getOrderedElement(), -1);
871    }
872    if (element.hasRulesElement()) {
873      composeEnum(t, "ElementDefinitionSlicingComponent", "rules", element.getRulesElement(), -1);
874    }
875  }
876
877  protected void composeElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) {
878    if (element == null) 
879      return;
880    Complex t;
881    if (Utilities.noString(parentType))
882      t = parent;
883    else {
884      t = parent.predicate("fhir:"+parentType+'.'+name);
885    }
886    composeElement(t, "discriminator", name, element, index);
887    if (element.hasTypeElement()) {
888      composeEnum(t, "ElementDefinitionSlicingDiscriminatorComponent", "type", element.getTypeElement(), -1);
889    }
890    if (element.hasPathElement()) {
891      composeString(t, "ElementDefinitionSlicingDiscriminatorComponent", "path", element.getPathElement(), -1);
892    }
893  }
894
895  protected void composeElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) {
896    if (element == null) 
897      return;
898    Complex t;
899    if (Utilities.noString(parentType))
900      t = parent;
901    else {
902      t = parent.predicate("fhir:"+parentType+'.'+name);
903    }
904    composeElement(t, "base", name, element, index);
905    if (element.hasPathElement()) {
906      composeString(t, "ElementDefinitionBaseComponent", "path", element.getPathElement(), -1);
907    }
908    if (element.hasMinElement()) {
909      composeUnsignedInt(t, "ElementDefinitionBaseComponent", "min", element.getMinElement(), -1);
910    }
911    if (element.hasMaxElement()) {
912      composeString(t, "ElementDefinitionBaseComponent", "max", element.getMaxElement(), -1);
913    }
914  }
915
916  protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) {
917    if (element == null) 
918      return;
919    Complex t;
920    if (Utilities.noString(parentType))
921      t = parent;
922    else {
923      t = parent.predicate("fhir:"+parentType+'.'+name);
924    }
925    composeElement(t, "type", name, element, index);
926    if (element.hasCodeElement()) {
927      composeUri(t, "TypeRefComponent", "code", element.getCodeElement(), -1);
928    }
929    for (int i = 0; i < element.getProfile().size(); i++) {
930      composeCanonical(t, "TypeRefComponent", "profile", element.getProfile().get(i), i);
931    }
932    for (int i = 0; i < element.getTargetProfile().size(); i++) {
933      composeCanonical(t, "TypeRefComponent", "targetProfile", element.getTargetProfile().get(i), i);
934    }
935    for (int i = 0; i < element.getAggregation().size(); i++) {
936      composeEnum(t, "TypeRefComponent", "aggregation", element.getAggregation().get(i), i);
937    }
938    if (element.hasVersioningElement()) {
939      composeEnum(t, "TypeRefComponent", "versioning", element.getVersioningElement(), -1);
940    }
941  }
942
943  protected void composeElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) {
944    if (element == null) 
945      return;
946    Complex t;
947    if (Utilities.noString(parentType))
948      t = parent;
949    else {
950      t = parent.predicate("fhir:"+parentType+'.'+name);
951    }
952    composeElement(t, "example", name, element, index);
953    if (element.hasLabelElement()) {
954      composeString(t, "ElementDefinitionExampleComponent", "label", element.getLabelElement(), -1);
955    }
956    if (element.hasValue()) {
957      composeType(t, "ElementDefinitionExampleComponent", "value", element.getValue(), -1);
958    }
959  }
960
961  protected void composeElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) {
962    if (element == null) 
963      return;
964    Complex t;
965    if (Utilities.noString(parentType))
966      t = parent;
967    else {
968      t = parent.predicate("fhir:"+parentType+'.'+name);
969    }
970    composeElement(t, "constraint", name, element, index);
971    if (element.hasKeyElement()) {
972      composeId(t, "ElementDefinitionConstraintComponent", "key", element.getKeyElement(), -1);
973    }
974    if (element.hasRequirementsElement()) {
975      composeString(t, "ElementDefinitionConstraintComponent", "requirements", element.getRequirementsElement(), -1);
976    }
977    if (element.hasSeverityElement()) {
978      composeEnum(t, "ElementDefinitionConstraintComponent", "severity", element.getSeverityElement(), -1);
979    }
980    if (element.hasHumanElement()) {
981      composeString(t, "ElementDefinitionConstraintComponent", "human", element.getHumanElement(), -1);
982    }
983    if (element.hasExpressionElement()) {
984      composeString(t, "ElementDefinitionConstraintComponent", "expression", element.getExpressionElement(), -1);
985    }
986    if (element.hasXpathElement()) {
987      composeString(t, "ElementDefinitionConstraintComponent", "xpath", element.getXpathElement(), -1);
988    }
989    if (element.hasSourceElement()) {
990      composeCanonical(t, "ElementDefinitionConstraintComponent", "source", element.getSourceElement(), -1);
991    }
992  }
993
994  protected void composeElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) {
995    if (element == null) 
996      return;
997    Complex t;
998    if (Utilities.noString(parentType))
999      t = parent;
1000    else {
1001      t = parent.predicate("fhir:"+parentType+'.'+name);
1002    }
1003    composeElement(t, "binding", name, element, index);
1004    if (element.hasStrengthElement()) {
1005      composeEnum(t, "ElementDefinitionBindingComponent", "strength", element.getStrengthElement(), -1);
1006    }
1007    if (element.hasDescriptionElement()) {
1008      composeString(t, "ElementDefinitionBindingComponent", "description", element.getDescriptionElement(), -1);
1009    }
1010    if (element.hasValueSetElement()) {
1011      composeCanonical(t, "ElementDefinitionBindingComponent", "valueSet", element.getValueSetElement(), -1);
1012    }
1013  }
1014
1015  protected void composeElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) {
1016    if (element == null) 
1017      return;
1018    Complex t;
1019    if (Utilities.noString(parentType))
1020      t = parent;
1021    else {
1022      t = parent.predicate("fhir:"+parentType+'.'+name);
1023    }
1024    composeElement(t, "mapping", name, element, index);
1025    if (element.hasIdentityElement()) {
1026      composeId(t, "ElementDefinitionMappingComponent", "identity", element.getIdentityElement(), -1);
1027    }
1028    if (element.hasLanguageElement()) {
1029      composeCode(t, "ElementDefinitionMappingComponent", "language", element.getLanguageElement(), -1);
1030    }
1031    if (element.hasMapElement()) {
1032      composeString(t, "ElementDefinitionMappingComponent", "map", element.getMapElement(), -1);
1033    }
1034    if (element.hasCommentElement()) {
1035      composeString(t, "ElementDefinitionMappingComponent", "comment", element.getCommentElement(), -1);
1036    }
1037  }
1038
1039  protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) {
1040    if (element == null) 
1041      return;
1042    Complex t;
1043    if (Utilities.noString(parentType))
1044      t = parent;
1045    else {
1046      t = parent.predicate("fhir:"+parentType+'.'+name);
1047    }
1048    composeDataType(t, "Expression", name, element, index);
1049    if (element.hasDescriptionElement()) {
1050      composeString(t, "Expression", "description", element.getDescriptionElement(), -1);
1051    }
1052    if (element.hasNameElement()) {
1053      composeId(t, "Expression", "name", element.getNameElement(), -1);
1054    }
1055    if (element.hasLanguageElement()) {
1056      composeCode(t, "Expression", "language", element.getLanguageElement(), -1);
1057    }
1058    if (element.hasExpressionElement()) {
1059      composeString(t, "Expression", "expression", element.getExpressionElement(), -1);
1060    }
1061    if (element.hasReferenceElement()) {
1062      composeUri(t, "Expression", "reference", element.getReferenceElement(), -1);
1063    }
1064  }
1065
1066  protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) {
1067    if (element == null) 
1068      return;
1069    Complex t;
1070    if (Utilities.noString(parentType))
1071      t = parent;
1072    else {
1073      t = parent.predicate("fhir:"+parentType+'.'+name);
1074    }
1075    composeDataType(t, "Extension", name, element, index);
1076    if (element.hasUrlElement()) {
1077      composeUri(t, "Extension", "url", element.getUrlElement(), -1);
1078    }
1079    if (element.hasValue()) {
1080      composeType(t, "Extension", "value", element.getValue(), -1);
1081    }
1082  }
1083
1084  protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) {
1085    if (element == null) 
1086      return;
1087    Complex t;
1088    if (Utilities.noString(parentType))
1089      t = parent;
1090    else {
1091      t = parent.predicate("fhir:"+parentType+'.'+name);
1092    }
1093    composeDataType(t, "HumanName", name, element, index);
1094    if (element.hasUseElement()) {
1095      composeEnum(t, "HumanName", "use", element.getUseElement(), -1);
1096    }
1097    if (element.hasTextElement()) {
1098      composeString(t, "HumanName", "text", element.getTextElement(), -1);
1099    }
1100    if (element.hasFamilyElement()) {
1101      composeString(t, "HumanName", "family", element.getFamilyElement(), -1);
1102    }
1103    for (int i = 0; i < element.getGiven().size(); i++) {
1104      composeString(t, "HumanName", "given", element.getGiven().get(i), i);
1105    }
1106    for (int i = 0; i < element.getPrefix().size(); i++) {
1107      composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i);
1108    }
1109    for (int i = 0; i < element.getSuffix().size(); i++) {
1110      composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i);
1111    }
1112    if (element.hasPeriod()) {
1113      composePeriod(t, "HumanName", "period", element.getPeriod(), -1);
1114    }
1115  }
1116
1117  protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) {
1118    if (element == null) 
1119      return;
1120    Complex t;
1121    if (Utilities.noString(parentType))
1122      t = parent;
1123    else {
1124      t = parent.predicate("fhir:"+parentType+'.'+name);
1125    }
1126    composeDataType(t, "Identifier", name, element, index);
1127    if (element.hasUseElement()) {
1128      composeEnum(t, "Identifier", "use", element.getUseElement(), -1);
1129    }
1130    if (element.hasType()) {
1131      composeCodeableConcept(t, "Identifier", "type", element.getType(), -1);
1132    }
1133    if (element.hasSystemElement()) {
1134      composeUri(t, "Identifier", "system", element.getSystemElement(), -1);
1135    }
1136    if (element.hasValueElement()) {
1137      composeString(t, "Identifier", "value", element.getValueElement(), -1);
1138    }
1139    if (element.hasPeriod()) {
1140      composePeriod(t, "Identifier", "period", element.getPeriod(), -1);
1141    }
1142    if (element.hasAssigner()) {
1143      composeReference(t, "Identifier", "assigner", element.getAssigner(), -1);
1144    }
1145  }
1146
1147  protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) {
1148    if (element == null) 
1149      return;
1150    Complex t;
1151    if (Utilities.noString(parentType))
1152      t = parent;
1153    else {
1154      t = parent.predicate("fhir:"+parentType+'.'+name);
1155    }
1156    composeBackboneType(t, "MarketingStatus", name, element, index);
1157    if (element.hasCountry()) {
1158      composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1);
1159    }
1160    if (element.hasJurisdiction()) {
1161      composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1);
1162    }
1163    if (element.hasStatus()) {
1164      composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1);
1165    }
1166    if (element.hasDateRange()) {
1167      composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1);
1168    }
1169    if (element.hasRestoreDateElement()) {
1170      composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1);
1171    }
1172  }
1173
1174  protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) {
1175    if (element == null) 
1176      return;
1177    Complex t;
1178    if (Utilities.noString(parentType))
1179      t = parent;
1180    else {
1181      t = parent.predicate("fhir:"+parentType+'.'+name);
1182    }
1183    composeElement(t, "Meta", name, element, index);
1184    if (element.hasVersionIdElement()) {
1185      composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1);
1186    }
1187    if (element.hasLastUpdatedElement()) {
1188      composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1);
1189    }
1190    if (element.hasSourceElement()) {
1191      composeUri(t, "Meta", "source", element.getSourceElement(), -1);
1192    }
1193    for (int i = 0; i < element.getProfile().size(); i++) {
1194      composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i);
1195    }
1196    for (int i = 0; i < element.getSecurity().size(); i++) {
1197      composeCoding(t, "Meta", "security", element.getSecurity().get(i), i);
1198    }
1199    for (int i = 0; i < element.getTag().size(); i++) {
1200      composeCoding(t, "Meta", "tag", element.getTag().get(i), i);
1201    }
1202  }
1203
1204  protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) {
1205    if (element == null) 
1206      return;
1207    Complex t;
1208    if (Utilities.noString(parentType))
1209      t = parent;
1210    else {
1211      t = parent.predicate("fhir:"+parentType+'.'+name);
1212    }
1213    composeDataType(t, "Money", name, element, index);
1214    if (element.hasValueElement()) {
1215      composeDecimal(t, "Money", "value", element.getValueElement(), -1);
1216    }
1217    if (element.hasCurrencyElement()) {
1218      composeCode(t, "Money", "currency", element.getCurrencyElement(), -1);
1219    }
1220  }
1221
1222  protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) {
1223    if (element == null) 
1224      return;
1225    Complex t;
1226    if (Utilities.noString(parentType))
1227      t = parent;
1228    else {
1229      t = parent.predicate("fhir:"+parentType+'.'+name);
1230    }
1231    composeDataType(t, "Narrative", name, element, index);
1232    if (element.hasStatusElement()) {
1233      composeEnum(t, "Narrative", "status", element.getStatusElement(), -1);
1234    }
1235    if (element.hasDiv()) {
1236      composeXhtmlNode(t, "Narrative", "div", element.getDiv(), -1);
1237    }
1238  }
1239
1240  protected void composeOrderedDistribution(Complex parent, String parentType, String name, OrderedDistribution element, int index) {
1241    if (element == null) 
1242      return;
1243    Complex t;
1244    if (Utilities.noString(parentType))
1245      t = parent;
1246    else {
1247      t = parent.predicate("fhir:"+parentType+'.'+name);
1248    }
1249    composeBackboneType(t, "OrderedDistribution", name, element, index);
1250    if (element.hasDescriptionElement()) {
1251      composeString(t, "OrderedDistribution", "description", element.getDescriptionElement(), -1);
1252    }
1253    for (int i = 0; i < element.getNote().size(); i++) {
1254      composeAnnotation(t, "OrderedDistribution", "note", element.getNote().get(i), i);
1255    }
1256    if (element.hasNumberOfIntervalsElement()) {
1257      composeInteger(t, "OrderedDistribution", "numberOfIntervals", element.getNumberOfIntervalsElement(), -1);
1258    }
1259    if (element.hasBottomOfFirstInterval()) {
1260      composeQuantity(t, "OrderedDistribution", "bottomOfFirstInterval", element.getBottomOfFirstInterval(), -1);
1261    }
1262    for (int i = 0; i < element.getInterval().size(); i++) {
1263      composeOrderedDistributionIntervalComponent(t, "OrderedDistribution", "interval", element.getInterval().get(i), i);
1264    }
1265    if (element.hasTopOfInterval()) {
1266      composeQuantity(t, "OrderedDistribution", "topOfInterval", element.getTopOfInterval(), -1);
1267    }
1268  }
1269
1270  protected void composeOrderedDistributionIntervalComponent(Complex parent, String parentType, String name, OrderedDistribution.OrderedDistributionIntervalComponent element, int index) {
1271    if (element == null) 
1272      return;
1273    Complex t;
1274    if (Utilities.noString(parentType))
1275      t = parent;
1276    else {
1277      t = parent.predicate("fhir:"+parentType+'.'+name);
1278    }
1279    composeElement(t, "interval", name, element, index);
1280    if (element.hasRankOrderElement()) {
1281      composeInteger(t, "OrderedDistributionIntervalComponent", "rankOrder", element.getRankOrderElement(), -1);
1282    }
1283    for (int i = 0; i < element.getIntervalStatistic().size(); i++) {
1284      composeStatistic(t, "OrderedDistributionIntervalComponent", "intervalStatistic", element.getIntervalStatistic().get(i), i);
1285    }
1286  }
1287
1288  protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) {
1289    if (element == null) 
1290      return;
1291    Complex t;
1292    if (Utilities.noString(parentType))
1293      t = parent;
1294    else {
1295      t = parent.predicate("fhir:"+parentType+'.'+name);
1296    }
1297    composeDataType(t, "ParameterDefinition", name, element, index);
1298    if (element.hasNameElement()) {
1299      composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1);
1300    }
1301    if (element.hasUseElement()) {
1302      composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1);
1303    }
1304    if (element.hasMinElement()) {
1305      composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1);
1306    }
1307    if (element.hasMaxElement()) {
1308      composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1);
1309    }
1310    if (element.hasDocumentationElement()) {
1311      composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1);
1312    }
1313    if (element.hasTypeElement()) {
1314      composeEnum(t, "ParameterDefinition", "type", element.getTypeElement(), -1);
1315    }
1316    if (element.hasProfileElement()) {
1317      composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1);
1318    }
1319  }
1320
1321  protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) {
1322    if (element == null) 
1323      return;
1324    Complex t;
1325    if (Utilities.noString(parentType))
1326      t = parent;
1327    else {
1328      t = parent.predicate("fhir:"+parentType+'.'+name);
1329    }
1330    composeDataType(t, "Period", name, element, index);
1331    if (element.hasStartElement()) {
1332      composeDateTime(t, "Period", "start", element.getStartElement(), -1);
1333    }
1334    if (element.hasEndElement()) {
1335      composeDateTime(t, "Period", "end", element.getEndElement(), -1);
1336    }
1337  }
1338
1339  protected void composePopulation(Complex parent, String parentType, String name, Population 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    composeBackboneType(t, "Population", name, element, index);
1349    if (element.hasAge()) {
1350      composeType(t, "Population", "age", element.getAge(), -1);
1351    }
1352    if (element.hasGender()) {
1353      composeCodeableConcept(t, "Population", "gender", element.getGender(), -1);
1354    }
1355    if (element.hasRace()) {
1356      composeCodeableConcept(t, "Population", "race", element.getRace(), -1);
1357    }
1358    if (element.hasPhysiologicalCondition()) {
1359      composeCodeableConcept(t, "Population", "physiologicalCondition", element.getPhysiologicalCondition(), -1);
1360    }
1361  }
1362
1363  protected void composeProdCharacteristic(Complex parent, String parentType, String name, ProdCharacteristic element, int index) {
1364    if (element == null) 
1365      return;
1366    Complex t;
1367    if (Utilities.noString(parentType))
1368      t = parent;
1369    else {
1370      t = parent.predicate("fhir:"+parentType+'.'+name);
1371    }
1372    composeBackboneType(t, "ProdCharacteristic", name, element, index);
1373    if (element.hasHeight()) {
1374      composeQuantity(t, "ProdCharacteristic", "height", element.getHeight(), -1);
1375    }
1376    if (element.hasWidth()) {
1377      composeQuantity(t, "ProdCharacteristic", "width", element.getWidth(), -1);
1378    }
1379    if (element.hasDepth()) {
1380      composeQuantity(t, "ProdCharacteristic", "depth", element.getDepth(), -1);
1381    }
1382    if (element.hasWeight()) {
1383      composeQuantity(t, "ProdCharacteristic", "weight", element.getWeight(), -1);
1384    }
1385    if (element.hasNominalVolume()) {
1386      composeQuantity(t, "ProdCharacteristic", "nominalVolume", element.getNominalVolume(), -1);
1387    }
1388    if (element.hasExternalDiameter()) {
1389      composeQuantity(t, "ProdCharacteristic", "externalDiameter", element.getExternalDiameter(), -1);
1390    }
1391    if (element.hasShapeElement()) {
1392      composeString(t, "ProdCharacteristic", "shape", element.getShapeElement(), -1);
1393    }
1394    for (int i = 0; i < element.getColor().size(); i++) {
1395      composeString(t, "ProdCharacteristic", "color", element.getColor().get(i), i);
1396    }
1397    for (int i = 0; i < element.getImprint().size(); i++) {
1398      composeString(t, "ProdCharacteristic", "imprint", element.getImprint().get(i), i);
1399    }
1400    for (int i = 0; i < element.getImage().size(); i++) {
1401      composeAttachment(t, "ProdCharacteristic", "image", element.getImage().get(i), i);
1402    }
1403    if (element.hasScoring()) {
1404      composeCodeableConcept(t, "ProdCharacteristic", "scoring", element.getScoring(), -1);
1405    }
1406  }
1407
1408  protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) {
1409    if (element == null) 
1410      return;
1411    Complex t;
1412    if (Utilities.noString(parentType))
1413      t = parent;
1414    else {
1415      t = parent.predicate("fhir:"+parentType+'.'+name);
1416    }
1417    composeBackboneType(t, "ProductShelfLife", name, element, index);
1418    if (element.hasIdentifier()) {
1419      composeIdentifier(t, "ProductShelfLife", "identifier", element.getIdentifier(), -1);
1420    }
1421    if (element.hasType()) {
1422      composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1);
1423    }
1424    if (element.hasPeriod()) {
1425      composeQuantity(t, "ProductShelfLife", "period", element.getPeriod(), -1);
1426    }
1427    for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++) {
1428      composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i);
1429    }
1430  }
1431
1432  protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) {
1433    if (element == null) 
1434      return;
1435    Complex t;
1436    if (Utilities.noString(parentType))
1437      t = parent;
1438    else {
1439      t = parent.predicate("fhir:"+parentType+'.'+name);
1440    }
1441    composeDataType(t, "Quantity", name, element, index);
1442    if (element.hasValueElement()) {
1443      composeDecimal(t, "Quantity", "value", element.getValueElement(), -1);
1444    }
1445    if (element.hasComparatorElement()) {
1446      composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1);
1447    }
1448    if (element.hasUnitElement()) {
1449      composeString(t, "Quantity", "unit", element.getUnitElement(), -1);
1450    }
1451    if (element.hasSystemElement()) {
1452      composeUri(t, "Quantity", "system", element.getSystemElement(), -1);
1453    }
1454    if (element.hasCodeElement()) {
1455      composeCode(t, "Quantity", "code", element.getCodeElement(), -1);
1456    }
1457  }
1458
1459  protected void composeRange(Complex parent, String parentType, String name, Range element, int index) {
1460    if (element == null) 
1461      return;
1462    Complex t;
1463    if (Utilities.noString(parentType))
1464      t = parent;
1465    else {
1466      t = parent.predicate("fhir:"+parentType+'.'+name);
1467    }
1468    composeDataType(t, "Range", name, element, index);
1469    if (element.hasLow()) {
1470      composeQuantity(t, "Range", "low", element.getLow(), -1);
1471    }
1472    if (element.hasHigh()) {
1473      composeQuantity(t, "Range", "high", element.getHigh(), -1);
1474    }
1475  }
1476
1477  protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) {
1478    if (element == null) 
1479      return;
1480    Complex t;
1481    if (Utilities.noString(parentType))
1482      t = parent;
1483    else {
1484      t = parent.predicate("fhir:"+parentType+'.'+name);
1485    }
1486    composeDataType(t, "Ratio", name, element, index);
1487    if (element.hasNumerator()) {
1488      composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1);
1489    }
1490    if (element.hasDenominator()) {
1491      composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1);
1492    }
1493  }
1494
1495  protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) {
1496    if (element == null) 
1497      return;
1498    Complex t;
1499    if (Utilities.noString(parentType))
1500      t = parent;
1501    else {
1502      t = parent.predicate("fhir:"+parentType+'.'+name);
1503    }
1504    composeDataType(t, "Reference", name, element, index);
1505    if (element.hasReferenceElement()) {
1506      composeString(t, "Reference", "reference", element.getReferenceElement_(), -1);
1507    }
1508    if (element.hasTypeElement()) {
1509      composeUri(t, "Reference", "type", element.getTypeElement(), -1);
1510    }
1511    if (element.hasIdentifier()) {
1512      composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1);
1513    }
1514    if (element.hasDisplayElement()) {
1515      composeString(t, "Reference", "display", element.getDisplayElement(), -1);
1516    }
1517  }
1518
1519  protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) {
1520    if (element == null) 
1521      return;
1522    Complex t;
1523    if (Utilities.noString(parentType))
1524      t = parent;
1525    else {
1526      t = parent.predicate("fhir:"+parentType+'.'+name);
1527    }
1528    composeDataType(t, "RelatedArtifact", name, element, index);
1529    if (element.hasTypeElement()) {
1530      composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1);
1531    }
1532    if (element.hasLabelElement()) {
1533      composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1);
1534    }
1535    if (element.hasDisplayElement()) {
1536      composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1);
1537    }
1538    if (element.hasCitationElement()) {
1539      composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1);
1540    }
1541    if (element.hasUrlElement()) {
1542      composeUrl(t, "RelatedArtifact", "url", element.getUrlElement(), -1);
1543    }
1544    if (element.hasDocument()) {
1545      composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1);
1546    }
1547    if (element.hasResourceElement()) {
1548      composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1);
1549    }
1550  }
1551
1552  protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) {
1553    if (element == null) 
1554      return;
1555    Complex t;
1556    if (Utilities.noString(parentType))
1557      t = parent;
1558    else {
1559      t = parent.predicate("fhir:"+parentType+'.'+name);
1560    }
1561    composeDataType(t, "SampledData", name, element, index);
1562    if (element.hasOrigin()) {
1563      composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1);
1564    }
1565    if (element.hasPeriodElement()) {
1566      composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1);
1567    }
1568    if (element.hasFactorElement()) {
1569      composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1);
1570    }
1571    if (element.hasLowerLimitElement()) {
1572      composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1);
1573    }
1574    if (element.hasUpperLimitElement()) {
1575      composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1);
1576    }
1577    if (element.hasDimensionsElement()) {
1578      composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1);
1579    }
1580    if (element.hasDataElement()) {
1581      composeString(t, "SampledData", "data", element.getDataElement(), -1);
1582    }
1583  }
1584
1585  protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) {
1586    if (element == null) 
1587      return;
1588    Complex t;
1589    if (Utilities.noString(parentType))
1590      t = parent;
1591    else {
1592      t = parent.predicate("fhir:"+parentType+'.'+name);
1593    }
1594    composeDataType(t, "Signature", name, element, index);
1595    for (int i = 0; i < element.getType().size(); i++) {
1596      composeCoding(t, "Signature", "type", element.getType().get(i), i);
1597    }
1598    if (element.hasWhenElement()) {
1599      composeInstant(t, "Signature", "when", element.getWhenElement(), -1);
1600    }
1601    if (element.hasWho()) {
1602      composeReference(t, "Signature", "who", element.getWho(), -1);
1603    }
1604    if (element.hasOnBehalfOf()) {
1605      composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1);
1606    }
1607    if (element.hasTargetFormatElement()) {
1608      composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1);
1609    }
1610    if (element.hasSigFormatElement()) {
1611      composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1);
1612    }
1613    if (element.hasDataElement()) {
1614      composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1);
1615    }
1616  }
1617
1618  protected void composeStatistic(Complex parent, String parentType, String name, Statistic element, int index) {
1619    if (element == null) 
1620      return;
1621    Complex t;
1622    if (Utilities.noString(parentType))
1623      t = parent;
1624    else {
1625      t = parent.predicate("fhir:"+parentType+'.'+name);
1626    }
1627    composeBackboneType(t, "Statistic", name, element, index);
1628    if (element.hasDescriptionElement()) {
1629      composeString(t, "Statistic", "description", element.getDescriptionElement(), -1);
1630    }
1631    for (int i = 0; i < element.getNote().size(); i++) {
1632      composeAnnotation(t, "Statistic", "note", element.getNote().get(i), i);
1633    }
1634    if (element.hasStatisticType()) {
1635      composeCodeableConcept(t, "Statistic", "statisticType", element.getStatisticType(), -1);
1636    }
1637    if (element.hasQuantity()) {
1638      composeQuantity(t, "Statistic", "quantity", element.getQuantity(), -1);
1639    }
1640    if (element.hasSampleSize()) {
1641      composeStatisticSampleSizeComponent(t, "Statistic", "sampleSize", element.getSampleSize(), -1);
1642    }
1643    for (int i = 0; i < element.getAttributeEstimate().size(); i++) {
1644      composeStatisticAttributeEstimateComponent(t, "Statistic", "attributeEstimate", element.getAttributeEstimate().get(i), i);
1645    }
1646  }
1647
1648  protected void composeStatisticSampleSizeComponent(Complex parent, String parentType, String name, Statistic.StatisticSampleSizeComponent element, int index) {
1649    if (element == null) 
1650      return;
1651    Complex t;
1652    if (Utilities.noString(parentType))
1653      t = parent;
1654    else {
1655      t = parent.predicate("fhir:"+parentType+'.'+name);
1656    }
1657    composeElement(t, "sampleSize", name, element, index);
1658    if (element.hasDescriptionElement()) {
1659      composeString(t, "StatisticSampleSizeComponent", "description", element.getDescriptionElement(), -1);
1660    }
1661    for (int i = 0; i < element.getNote().size(); i++) {
1662      composeAnnotation(t, "StatisticSampleSizeComponent", "note", element.getNote().get(i), i);
1663    }
1664    if (element.hasNumberOfStudiesElement()) {
1665      composeInteger(t, "StatisticSampleSizeComponent", "numberOfStudies", element.getNumberOfStudiesElement(), -1);
1666    }
1667    if (element.hasNumberOfParticipantsElement()) {
1668      composeInteger(t, "StatisticSampleSizeComponent", "numberOfParticipants", element.getNumberOfParticipantsElement(), -1);
1669    }
1670    if (element.hasKnownDataCountElement()) {
1671      composeInteger(t, "StatisticSampleSizeComponent", "knownDataCount", element.getKnownDataCountElement(), -1);
1672    }
1673    if (element.hasNumeratorCountElement()) {
1674      composeInteger(t, "StatisticSampleSizeComponent", "numeratorCount", element.getNumeratorCountElement(), -1);
1675    }
1676  }
1677
1678  protected void composeStatisticAttributeEstimateComponent(Complex parent, String parentType, String name, Statistic.StatisticAttributeEstimateComponent element, int index) {
1679    if (element == null) 
1680      return;
1681    Complex t;
1682    if (Utilities.noString(parentType))
1683      t = parent;
1684    else {
1685      t = parent.predicate("fhir:"+parentType+'.'+name);
1686    }
1687    composeElement(t, "attributeEstimate", name, element, index);
1688    if (element.hasDescriptionElement()) {
1689      composeString(t, "StatisticAttributeEstimateComponent", "description", element.getDescriptionElement(), -1);
1690    }
1691    for (int i = 0; i < element.getNote().size(); i++) {
1692      composeAnnotation(t, "StatisticAttributeEstimateComponent", "note", element.getNote().get(i), i);
1693    }
1694    if (element.hasType()) {
1695      composeCodeableConcept(t, "StatisticAttributeEstimateComponent", "type", element.getType(), -1);
1696    }
1697    if (element.hasQuantity()) {
1698      composeQuantity(t, "StatisticAttributeEstimateComponent", "quantity", element.getQuantity(), -1);
1699    }
1700    if (element.hasLevelElement()) {
1701      composeDecimal(t, "StatisticAttributeEstimateComponent", "level", element.getLevelElement(), -1);
1702    }
1703    if (element.hasRange()) {
1704      composeRange(t, "StatisticAttributeEstimateComponent", "range", element.getRange(), -1);
1705    }
1706    for (int i = 0; i < element.getEstimateQualifier().size(); i++) {
1707      composeStatisticAttributeEstimateEstimateQualifierComponent(t, "StatisticAttributeEstimateComponent", "estimateQualifier", element.getEstimateQualifier().get(i), i);
1708    }
1709  }
1710
1711  protected void composeStatisticAttributeEstimateEstimateQualifierComponent(Complex parent, String parentType, String name, Statistic.StatisticAttributeEstimateEstimateQualifierComponent element, int index) {
1712    if (element == null) 
1713      return;
1714    Complex t;
1715    if (Utilities.noString(parentType))
1716      t = parent;
1717    else {
1718      t = parent.predicate("fhir:"+parentType+'.'+name);
1719    }
1720    composeElement(t, "estimateQualifier", name, element, index);
1721    if (element.hasDescriptionElement()) {
1722      composeString(t, "StatisticAttributeEstimateEstimateQualifierComponent", "description", element.getDescriptionElement(), -1);
1723    }
1724    for (int i = 0; i < element.getNote().size(); i++) {
1725      composeAnnotation(t, "StatisticAttributeEstimateEstimateQualifierComponent", "note", element.getNote().get(i), i);
1726    }
1727    if (element.hasType()) {
1728      composeCodeableConcept(t, "StatisticAttributeEstimateEstimateQualifierComponent", "type", element.getType(), -1);
1729    }
1730    if (element.hasQuantity()) {
1731      composeQuantity(t, "StatisticAttributeEstimateEstimateQualifierComponent", "quantity", element.getQuantity(), -1);
1732    }
1733    if (element.hasLevelElement()) {
1734      composeDecimal(t, "StatisticAttributeEstimateEstimateQualifierComponent", "level", element.getLevelElement(), -1);
1735    }
1736    if (element.hasRange()) {
1737      composeRange(t, "StatisticAttributeEstimateEstimateQualifierComponent", "range", element.getRange(), -1);
1738    }
1739  }
1740
1741  protected void composeSubstanceAmount(Complex parent, String parentType, String name, SubstanceAmount element, int index) {
1742    if (element == null) 
1743      return;
1744    Complex t;
1745    if (Utilities.noString(parentType))
1746      t = parent;
1747    else {
1748      t = parent.predicate("fhir:"+parentType+'.'+name);
1749    }
1750    composeBackboneType(t, "SubstanceAmount", name, element, index);
1751    if (element.hasAmount()) {
1752      composeType(t, "SubstanceAmount", "amount", element.getAmount(), -1);
1753    }
1754    if (element.hasAmountType()) {
1755      composeCodeableConcept(t, "SubstanceAmount", "amountType", element.getAmountType(), -1);
1756    }
1757    if (element.hasAmountTextElement()) {
1758      composeString(t, "SubstanceAmount", "amountText", element.getAmountTextElement(), -1);
1759    }
1760    if (element.hasReferenceRange()) {
1761      composeSubstanceAmountReferenceRangeComponent(t, "SubstanceAmount", "referenceRange", element.getReferenceRange(), -1);
1762    }
1763  }
1764
1765  protected void composeSubstanceAmountReferenceRangeComponent(Complex parent, String parentType, String name, SubstanceAmount.SubstanceAmountReferenceRangeComponent element, int index) {
1766    if (element == null) 
1767      return;
1768    Complex t;
1769    if (Utilities.noString(parentType))
1770      t = parent;
1771    else {
1772      t = parent.predicate("fhir:"+parentType+'.'+name);
1773    }
1774    composeElement(t, "referenceRange", name, element, index);
1775    if (element.hasLowLimit()) {
1776      composeQuantity(t, "SubstanceAmountReferenceRangeComponent", "lowLimit", element.getLowLimit(), -1);
1777    }
1778    if (element.hasHighLimit()) {
1779      composeQuantity(t, "SubstanceAmountReferenceRangeComponent", "highLimit", element.getHighLimit(), -1);
1780    }
1781  }
1782
1783  protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) {
1784    if (element == null) 
1785      return;
1786    Complex t;
1787    if (Utilities.noString(parentType))
1788      t = parent;
1789    else {
1790      t = parent.predicate("fhir:"+parentType+'.'+name);
1791    }
1792    composeBackboneType(t, "Timing", name, element, index);
1793    for (int i = 0; i < element.getEvent().size(); i++) {
1794      composeDateTime(t, "Timing", "event", element.getEvent().get(i), i);
1795    }
1796    if (element.hasRepeat()) {
1797      composeTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1);
1798    }
1799    if (element.hasCode()) {
1800      composeCodeableConcept(t, "Timing", "code", element.getCode(), -1);
1801    }
1802  }
1803
1804  protected void composeTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) {
1805    if (element == null) 
1806      return;
1807    Complex t;
1808    if (Utilities.noString(parentType))
1809      t = parent;
1810    else {
1811      t = parent.predicate("fhir:"+parentType+'.'+name);
1812    }
1813    composeElement(t, "repeat", name, element, index);
1814    if (element.hasBounds()) {
1815      composeType(t, "TimingRepeatComponent", "bounds", element.getBounds(), -1);
1816    }
1817    if (element.hasCountElement()) {
1818      composePositiveInt(t, "TimingRepeatComponent", "count", element.getCountElement(), -1);
1819    }
1820    if (element.hasCountMaxElement()) {
1821      composePositiveInt(t, "TimingRepeatComponent", "countMax", element.getCountMaxElement(), -1);
1822    }
1823    if (element.hasDurationElement()) {
1824      composeDecimal(t, "TimingRepeatComponent", "duration", element.getDurationElement(), -1);
1825    }
1826    if (element.hasDurationMaxElement()) {
1827      composeDecimal(t, "TimingRepeatComponent", "durationMax", element.getDurationMaxElement(), -1);
1828    }
1829    if (element.hasDurationUnitElement()) {
1830      composeEnum(t, "TimingRepeatComponent", "durationUnit", element.getDurationUnitElement(), -1);
1831    }
1832    if (element.hasFrequencyElement()) {
1833      composePositiveInt(t, "TimingRepeatComponent", "frequency", element.getFrequencyElement(), -1);
1834    }
1835    if (element.hasFrequencyMaxElement()) {
1836      composePositiveInt(t, "TimingRepeatComponent", "frequencyMax", element.getFrequencyMaxElement(), -1);
1837    }
1838    if (element.hasPeriodElement()) {
1839      composeDecimal(t, "TimingRepeatComponent", "period", element.getPeriodElement(), -1);
1840    }
1841    if (element.hasPeriodMaxElement()) {
1842      composeDecimal(t, "TimingRepeatComponent", "periodMax", element.getPeriodMaxElement(), -1);
1843    }
1844    if (element.hasPeriodUnitElement()) {
1845      composeEnum(t, "TimingRepeatComponent", "periodUnit", element.getPeriodUnitElement(), -1);
1846    }
1847    for (int i = 0; i < element.getDayOfWeek().size(); i++) {
1848      composeEnum(t, "TimingRepeatComponent", "dayOfWeek", element.getDayOfWeek().get(i), i);
1849    }
1850    for (int i = 0; i < element.getTimeOfDay().size(); i++) {
1851      composeTime(t, "TimingRepeatComponent", "timeOfDay", element.getTimeOfDay().get(i), i);
1852    }
1853    for (int i = 0; i < element.getWhen().size(); i++) {
1854      composeEnum(t, "TimingRepeatComponent", "when", element.getWhen().get(i), i);
1855    }
1856    if (element.hasOffsetElement()) {
1857      composeUnsignedInt(t, "TimingRepeatComponent", "offset", element.getOffsetElement(), -1);
1858    }
1859  }
1860
1861  protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) {
1862    if (element == null) 
1863      return;
1864    Complex t;
1865    if (Utilities.noString(parentType))
1866      t = parent;
1867    else {
1868      t = parent.predicate("fhir:"+parentType+'.'+name);
1869    }
1870    composeDataType(t, "TriggerDefinition", name, element, index);
1871    if (element.hasTypeElement()) {
1872      composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1);
1873    }
1874    if (element.hasNameElement()) {
1875      composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1);
1876    }
1877    if (element.hasTiming()) {
1878      composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1);
1879    }
1880    for (int i = 0; i < element.getData().size(); i++) {
1881      composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i);
1882    }
1883    if (element.hasCondition()) {
1884      composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1);
1885    }
1886  }
1887
1888  protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) {
1889    if (element == null) 
1890      return;
1891    Complex t;
1892    if (Utilities.noString(parentType))
1893      t = parent;
1894    else {
1895      t = parent.predicate("fhir:"+parentType+'.'+name);
1896    }
1897    composeDataType(t, "UsageContext", name, element, index);
1898    if (element.hasCode()) {
1899      composeCoding(t, "UsageContext", "code", element.getCode(), -1);
1900    }
1901    if (element.hasValue()) {
1902      composeType(t, "UsageContext", "value", element.getValue(), -1);
1903    }
1904  }
1905
1906  protected void composeCanonicalResource(Complex t, String parentType, String name, CanonicalResource element, int index) {
1907    composeDomainResource(t, parentType, name, element, index);
1908    if (element.hasUrlElement()) {
1909      composeUri(t, "CanonicalResource", "url", element.getUrlElement(), -1);
1910    }
1911    for (int i = 0; i < element.getIdentifier().size(); i++) {
1912      composeIdentifier(t, "CanonicalResource", "identifier", element.getIdentifier().get(i), i);
1913    }
1914    if (element.hasVersionElement()) {
1915      composeString(t, "CanonicalResource", "version", element.getVersionElement(), -1);
1916    }
1917    if (element.hasNameElement()) {
1918      composeString(t, "CanonicalResource", "name", element.getNameElement(), -1);
1919    }
1920    if (element.hasTitleElement()) {
1921      composeString(t, "CanonicalResource", "title", element.getTitleElement(), -1);
1922    }
1923    if (element.hasStatusElement()) {
1924      composeEnum(t, "CanonicalResource", "status", element.getStatusElement(), -1);
1925    }
1926    if (element.hasExperimentalElement()) {
1927      composeBoolean(t, "CanonicalResource", "experimental", element.getExperimentalElement(), -1);
1928    }
1929    if (element.hasDateElement()) {
1930      composeDateTime(t, "CanonicalResource", "date", element.getDateElement(), -1);
1931    }
1932    if (element.hasPublisherElement()) {
1933      composeString(t, "CanonicalResource", "publisher", element.getPublisherElement(), -1);
1934    }
1935    for (int i = 0; i < element.getContact().size(); i++) {
1936      composeContactDetail(t, "CanonicalResource", "contact", element.getContact().get(i), i);
1937    }
1938    if (element.hasDescriptionElement()) {
1939      composeMarkdown(t, "CanonicalResource", "description", element.getDescriptionElement(), -1);
1940    }
1941    for (int i = 0; i < element.getUseContext().size(); i++) {
1942      composeUsageContext(t, "CanonicalResource", "useContext", element.getUseContext().get(i), i);
1943    }
1944    for (int i = 0; i < element.getJurisdiction().size(); i++) {
1945      composeCodeableConcept(t, "CanonicalResource", "jurisdiction", element.getJurisdiction().get(i), i);
1946    }
1947    if (element.hasPurposeElement()) {
1948      composeMarkdown(t, "CanonicalResource", "purpose", element.getPurposeElement(), -1);
1949    }
1950    if (element.hasCopyrightElement()) {
1951      composeMarkdown(t, "CanonicalResource", "copyright", element.getCopyrightElement(), -1);
1952    }
1953  }
1954
1955  protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) {
1956    composeResource(t, parentType, name, element, index);
1957    if (element.hasText()) {
1958      composeNarrative(t, "DomainResource", "text", element.getText(), -1);
1959    }
1960    for (int i = 0; i < element.getContained().size(); i++) {
1961      composeResource(t, "DomainResource", "contained", element.getContained().get(i), i);
1962    }
1963    for (int i = 0; i < element.getExtension().size(); i++) {
1964      composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i);
1965    }
1966    for (int i = 0; i < element.getModifierExtension().size(); i++) {
1967      composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i);
1968    }
1969  }
1970
1971  protected void composeMetadataResource(Complex t, String parentType, String name, MetadataResource element, int index) {
1972    composeCanonicalResource(t, parentType, name, element, index);
1973    if (element.hasApprovalDateElement()) {
1974      composeDate(t, "MetadataResource", "approvalDate", element.getApprovalDateElement(), -1);
1975    }
1976    if (element.hasLastReviewDateElement()) {
1977      composeDate(t, "MetadataResource", "lastReviewDate", element.getLastReviewDateElement(), -1);
1978    }
1979    if (element.hasEffectivePeriod()) {
1980      composePeriod(t, "MetadataResource", "effectivePeriod", element.getEffectivePeriod(), -1);
1981    }
1982  }
1983
1984  protected void composeResource(Complex t, String parentType, String name, Resource element, int index) {
1985    composeBase(t, parentType, name, element, index);
1986    if (element.hasIdElement()) {
1987      composeId(t, "Resource", "id", element.getIdElement(), -1);
1988    }
1989    if (element.hasMeta()) {
1990      composeMeta(t, "Resource", "meta", element.getMeta(), -1);
1991    }
1992    if (element.hasImplicitRulesElement()) {
1993      composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1);
1994    }
1995    if (element.hasLanguageElement()) {
1996      composeCode(t, "Resource", "language", element.getLanguageElement(), -1);
1997    }
1998  }
1999
2000  protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) {
2001    if (element == null) 
2002      return;
2003    Complex t;
2004    if (Utilities.noString(parentType))
2005      t = parent;
2006    else {
2007      t = parent.predicate("fhir:"+parentType+'.'+name);
2008    }
2009    composeDomainResource(t, "Account", name, element, index);
2010    for (int i = 0; i < element.getIdentifier().size(); i++) {
2011      composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i);
2012    }
2013    if (element.hasStatusElement()) {
2014      composeEnum(t, "Account", "status", element.getStatusElement(), -1);
2015    }
2016    if (element.hasType()) {
2017      composeCodeableConcept(t, "Account", "type", element.getType(), -1);
2018    }
2019    if (element.hasNameElement()) {
2020      composeString(t, "Account", "name", element.getNameElement(), -1);
2021    }
2022    for (int i = 0; i < element.getSubject().size(); i++) {
2023      composeReference(t, "Account", "subject", element.getSubject().get(i), i);
2024    }
2025    if (element.hasServicePeriod()) {
2026      composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1);
2027    }
2028    for (int i = 0; i < element.getCoverage().size(); i++) {
2029      composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i);
2030    }
2031    if (element.hasOwner()) {
2032      composeReference(t, "Account", "owner", element.getOwner(), -1);
2033    }
2034    if (element.hasDescriptionElement()) {
2035      composeString(t, "Account", "description", element.getDescriptionElement(), -1);
2036    }
2037    for (int i = 0; i < element.getGuarantor().size(); i++) {
2038      composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i);
2039    }
2040    if (element.hasPartOf()) {
2041      composeReference(t, "Account", "partOf", element.getPartOf(), -1);
2042    }
2043  }
2044
2045  protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) {
2046    if (element == null) 
2047      return;
2048    Complex t;
2049    if (Utilities.noString(parentType))
2050      t = parent;
2051    else {
2052      t = parent.predicate("fhir:"+parentType+'.'+name);
2053    }
2054    composeBackboneElement(t, "coverage", name, element, index);
2055    if (element.hasCoverage()) {
2056      composeReference(t, "CoverageComponent", "coverage", element.getCoverage(), -1);
2057    }
2058    if (element.hasPriorityElement()) {
2059      composePositiveInt(t, "CoverageComponent", "priority", element.getPriorityElement(), -1);
2060    }
2061  }
2062
2063  protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) {
2064    if (element == null) 
2065      return;
2066    Complex t;
2067    if (Utilities.noString(parentType))
2068      t = parent;
2069    else {
2070      t = parent.predicate("fhir:"+parentType+'.'+name);
2071    }
2072    composeBackboneElement(t, "guarantor", name, element, index);
2073    if (element.hasParty()) {
2074      composeReference(t, "GuarantorComponent", "party", element.getParty(), -1);
2075    }
2076    if (element.hasOnHoldElement()) {
2077      composeBoolean(t, "GuarantorComponent", "onHold", element.getOnHoldElement(), -1);
2078    }
2079    if (element.hasPeriod()) {
2080      composePeriod(t, "GuarantorComponent", "period", element.getPeriod(), -1);
2081    }
2082  }
2083
2084  protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition 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    composeMetadataResource(t, "ActivityDefinition", name, element, index);
2094    if (element.hasUrlElement()) {
2095      composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1);
2096    }
2097    for (int i = 0; i < element.getIdentifier().size(); i++) {
2098      composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i);
2099    }
2100    if (element.hasVersionElement()) {
2101      composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1);
2102    }
2103    if (element.hasNameElement()) {
2104      composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1);
2105    }
2106    if (element.hasTitleElement()) {
2107      composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1);
2108    }
2109    if (element.hasSubtitleElement()) {
2110      composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1);
2111    }
2112    if (element.hasStatusElement()) {
2113      composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1);
2114    }
2115    if (element.hasExperimentalElement()) {
2116      composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1);
2117    }
2118    if (element.hasSubject()) {
2119      composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1);
2120    }
2121    if (element.hasDateElement()) {
2122      composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1);
2123    }
2124    if (element.hasPublisherElement()) {
2125      composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1);
2126    }
2127    for (int i = 0; i < element.getContact().size(); i++) {
2128      composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i);
2129    }
2130    if (element.hasDescriptionElement()) {
2131      composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1);
2132    }
2133    for (int i = 0; i < element.getUseContext().size(); i++) {
2134      composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i);
2135    }
2136    for (int i = 0; i < element.getJurisdiction().size(); i++) {
2137      composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
2138    }
2139    if (element.hasPurposeElement()) {
2140      composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1);
2141    }
2142    if (element.hasUsageElement()) {
2143      composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1);
2144    }
2145    if (element.hasCopyrightElement()) {
2146      composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1);
2147    }
2148    if (element.hasApprovalDateElement()) {
2149      composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1);
2150    }
2151    if (element.hasLastReviewDateElement()) {
2152      composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
2153    }
2154    if (element.hasEffectivePeriod()) {
2155      composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
2156    }
2157    for (int i = 0; i < element.getTopic().size(); i++) {
2158      composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i);
2159    }
2160    for (int i = 0; i < element.getAuthor().size(); i++) {
2161      composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i);
2162    }
2163    for (int i = 0; i < element.getEditor().size(); i++) {
2164      composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i);
2165    }
2166    for (int i = 0; i < element.getReviewer().size(); i++) {
2167      composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i);
2168    }
2169    for (int i = 0; i < element.getEndorser().size(); i++) {
2170      composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i);
2171    }
2172    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
2173      composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
2174    }
2175    for (int i = 0; i < element.getLibrary().size(); i++) {
2176      composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i);
2177    }
2178    if (element.hasKindElement()) {
2179      composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1);
2180    }
2181    if (element.hasProfileElement()) {
2182      composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1);
2183    }
2184    if (element.hasCode()) {
2185      composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1);
2186    }
2187    if (element.hasIntentElement()) {
2188      composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1);
2189    }
2190    if (element.hasPriorityElement()) {
2191      composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1);
2192    }
2193    if (element.hasDoNotPerformElement()) {
2194      composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1);
2195    }
2196    if (element.hasTiming()) {
2197      composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1);
2198    }
2199    if (element.hasLocation()) {
2200      composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1);
2201    }
2202    for (int i = 0; i < element.getParticipant().size(); i++) {
2203      composeActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i);
2204    }
2205    if (element.hasProduct()) {
2206      composeType(t, "ActivityDefinition", "product", element.getProduct(), -1);
2207    }
2208    if (element.hasQuantity()) {
2209      composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1);
2210    }
2211    for (int i = 0; i < element.getDosage().size(); i++) {
2212      composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i);
2213    }
2214    for (int i = 0; i < element.getBodySite().size(); i++) {
2215      composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i);
2216    }
2217    for (int i = 0; i < element.getSpecimenRequirement().size(); i++) {
2218      composeReference(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i);
2219    }
2220    for (int i = 0; i < element.getObservationRequirement().size(); i++) {
2221      composeReference(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i);
2222    }
2223    for (int i = 0; i < element.getObservationResultRequirement().size(); i++) {
2224      composeReference(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i);
2225    }
2226    if (element.hasTransformElement()) {
2227      composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1);
2228    }
2229    for (int i = 0; i < element.getDynamicValue().size(); i++) {
2230      composeActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i);
2231    }
2232  }
2233
2234  protected void composeActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) {
2235    if (element == null) 
2236      return;
2237    Complex t;
2238    if (Utilities.noString(parentType))
2239      t = parent;
2240    else {
2241      t = parent.predicate("fhir:"+parentType+'.'+name);
2242    }
2243    composeBackboneElement(t, "participant", name, element, index);
2244    if (element.hasTypeElement()) {
2245      composeEnum(t, "ActivityDefinitionParticipantComponent", "type", element.getTypeElement(), -1);
2246    }
2247    if (element.hasRole()) {
2248      composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "role", element.getRole(), -1);
2249    }
2250  }
2251
2252  protected void composeActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) {
2253    if (element == null) 
2254      return;
2255    Complex t;
2256    if (Utilities.noString(parentType))
2257      t = parent;
2258    else {
2259      t = parent.predicate("fhir:"+parentType+'.'+name);
2260    }
2261    composeBackboneElement(t, "dynamicValue", name, element, index);
2262    if (element.hasPathElement()) {
2263      composeString(t, "ActivityDefinitionDynamicValueComponent", "path", element.getPathElement(), -1);
2264    }
2265    if (element.hasExpression()) {
2266      composeExpression(t, "ActivityDefinitionDynamicValueComponent", "expression", element.getExpression(), -1);
2267    }
2268  }
2269
2270  protected void composeAdministrableProductDefinition(Complex parent, String parentType, String name, AdministrableProductDefinition element, int index) {
2271    if (element == null) 
2272      return;
2273    Complex t;
2274    if (Utilities.noString(parentType))
2275      t = parent;
2276    else {
2277      t = parent.predicate("fhir:"+parentType+'.'+name);
2278    }
2279    composeDomainResource(t, "AdministrableProductDefinition", name, element, index);
2280    for (int i = 0; i < element.getIdentifier().size(); i++) {
2281      composeIdentifier(t, "AdministrableProductDefinition", "identifier", element.getIdentifier().get(i), i);
2282    }
2283    for (int i = 0; i < element.getSubject().size(); i++) {
2284      composeReference(t, "AdministrableProductDefinition", "subject", element.getSubject().get(i), i);
2285    }
2286    if (element.hasAdministrableDoseForm()) {
2287      composeCodeableConcept(t, "AdministrableProductDefinition", "administrableDoseForm", element.getAdministrableDoseForm(), -1);
2288    }
2289    if (element.hasUnitOfPresentation()) {
2290      composeCodeableConcept(t, "AdministrableProductDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1);
2291    }
2292    for (int i = 0; i < element.getProducedFrom().size(); i++) {
2293      composeReference(t, "AdministrableProductDefinition", "producedFrom", element.getProducedFrom().get(i), i);
2294    }
2295    for (int i = 0; i < element.getIngredient().size(); i++) {
2296      composeReference(t, "AdministrableProductDefinition", "ingredient", element.getIngredient().get(i), i);
2297    }
2298    for (int i = 0; i < element.getDevice().size(); i++) {
2299      composeReference(t, "AdministrableProductDefinition", "device", element.getDevice().get(i), i);
2300    }
2301    for (int i = 0; i < element.getCharacteristic().size(); i++) {
2302      composeAdministrableProductDefinitionCharacteristicComponent(t, "AdministrableProductDefinition", "characteristic", element.getCharacteristic().get(i), i);
2303    }
2304    for (int i = 0; i < element.getRouteOfAdministration().size(); i++) {
2305      composeAdministrableProductDefinitionRouteOfAdministrationComponent(t, "AdministrableProductDefinition", "routeOfAdministration", element.getRouteOfAdministration().get(i), i);
2306    }
2307  }
2308
2309  protected void composeAdministrableProductDefinitionCharacteristicComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionCharacteristicComponent element, int index) {
2310    if (element == null) 
2311      return;
2312    Complex t;
2313    if (Utilities.noString(parentType))
2314      t = parent;
2315    else {
2316      t = parent.predicate("fhir:"+parentType+'.'+name);
2317    }
2318    composeBackboneElement(t, "characteristic", name, element, index);
2319    if (element.hasCode()) {
2320      composeCodeableConcept(t, "AdministrableProductDefinitionCharacteristicComponent", "code", element.getCode(), -1);
2321    }
2322    if (element.hasValue()) {
2323      composeType(t, "AdministrableProductDefinitionCharacteristicComponent", "value", element.getValue(), -1);
2324    }
2325    if (element.hasStatus()) {
2326      composeCodeableConcept(t, "AdministrableProductDefinitionCharacteristicComponent", "status", element.getStatus(), -1);
2327    }
2328  }
2329
2330  protected void composeAdministrableProductDefinitionRouteOfAdministrationComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent element, int index) {
2331    if (element == null) 
2332      return;
2333    Complex t;
2334    if (Utilities.noString(parentType))
2335      t = parent;
2336    else {
2337      t = parent.predicate("fhir:"+parentType+'.'+name);
2338    }
2339    composeBackboneElement(t, "routeOfAdministration", name, element, index);
2340    if (element.hasCode()) {
2341      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "code", element.getCode(), -1);
2342    }
2343    if (element.hasFirstDose()) {
2344      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "firstDose", element.getFirstDose(), -1);
2345    }
2346    if (element.hasMaxSingleDose()) {
2347      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxSingleDose", element.getMaxSingleDose(), -1);
2348    }
2349    if (element.hasMaxDosePerDay()) {
2350      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerDay", element.getMaxDosePerDay(), -1);
2351    }
2352    if (element.hasMaxDosePerTreatmentPeriod()) {
2353      composeRatio(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerTreatmentPeriod", element.getMaxDosePerTreatmentPeriod(), -1);
2354    }
2355    if (element.hasMaxTreatmentPeriod()) {
2356      composeDuration(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxTreatmentPeriod", element.getMaxTreatmentPeriod(), -1);
2357    }
2358    for (int i = 0; i < element.getTargetSpecies().size(); i++) {
2359      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "targetSpecies", element.getTargetSpecies().get(i), i);
2360    }
2361  }
2362
2363  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent element, int index) {
2364    if (element == null) 
2365      return;
2366    Complex t;
2367    if (Utilities.noString(parentType))
2368      t = parent;
2369    else {
2370      t = parent.predicate("fhir:"+parentType+'.'+name);
2371    }
2372    composeBackboneElement(t, "targetSpecies", name, element, index);
2373    if (element.hasCode()) {
2374      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "code", element.getCode(), -1);
2375    }
2376    for (int i = 0; i < element.getWithdrawalPeriod().size(); i++) {
2377      composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "withdrawalPeriod", element.getWithdrawalPeriod().get(i), i);
2378    }
2379  }
2380
2381  protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent element, int index) {
2382    if (element == null) 
2383      return;
2384    Complex t;
2385    if (Utilities.noString(parentType))
2386      t = parent;
2387    else {
2388      t = parent.predicate("fhir:"+parentType+'.'+name);
2389    }
2390    composeBackboneElement(t, "withdrawalPeriod", name, element, index);
2391    if (element.hasTissue()) {
2392      composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "tissue", element.getTissue(), -1);
2393    }
2394    if (element.hasValue()) {
2395      composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "value", element.getValue(), -1);
2396    }
2397    if (element.hasSupportingInformationElement()) {
2398      composeString(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "supportingInformation", element.getSupportingInformationElement(), -1);
2399    }
2400  }
2401
2402  protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) {
2403    if (element == null) 
2404      return;
2405    Complex t;
2406    if (Utilities.noString(parentType))
2407      t = parent;
2408    else {
2409      t = parent.predicate("fhir:"+parentType+'.'+name);
2410    }
2411    composeDomainResource(t, "AdverseEvent", name, element, index);
2412    for (int i = 0; i < element.getIdentifier().size(); i++) {
2413      composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier().get(i), i);
2414    }
2415    if (element.hasStatusElement()) {
2416      composeEnum(t, "AdverseEvent", "status", element.getStatusElement(), -1);
2417    }
2418    if (element.hasActualityElement()) {
2419      composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1);
2420    }
2421    for (int i = 0; i < element.getCategory().size(); i++) {
2422      composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i);
2423    }
2424    if (element.hasCode()) {
2425      composeCodeableConcept(t, "AdverseEvent", "code", element.getCode(), -1);
2426    }
2427    if (element.hasSubject()) {
2428      composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1);
2429    }
2430    if (element.hasEncounter()) {
2431      composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1);
2432    }
2433    if (element.hasOccurrence()) {
2434      composeType(t, "AdverseEvent", "occurrence", element.getOccurrence(), -1);
2435    }
2436    if (element.hasDetectedElement()) {
2437      composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1);
2438    }
2439    if (element.hasRecordedDateElement()) {
2440      composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1);
2441    }
2442    for (int i = 0; i < element.getResultingCondition().size(); i++) {
2443      composeReference(t, "AdverseEvent", "resultingCondition", element.getResultingCondition().get(i), i);
2444    }
2445    if (element.hasLocation()) {
2446      composeReference(t, "AdverseEvent", "location", element.getLocation(), -1);
2447    }
2448    if (element.hasSeriousness()) {
2449      composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1);
2450    }
2451    if (element.hasOutcome()) {
2452      composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1);
2453    }
2454    if (element.hasRecorder()) {
2455      composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1);
2456    }
2457    for (int i = 0; i < element.getParticipant().size(); i++) {
2458      composeAdverseEventParticipantComponent(t, "AdverseEvent", "participant", element.getParticipant().get(i), i);
2459    }
2460    for (int i = 0; i < element.getSuspectEntity().size(); i++) {
2461      composeAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i);
2462    }
2463    for (int i = 0; i < element.getContributingFactor().size(); i++) {
2464      composeAdverseEventContributingFactorComponent(t, "AdverseEvent", "contributingFactor", element.getContributingFactor().get(i), i);
2465    }
2466    for (int i = 0; i < element.getPreventiveAction().size(); i++) {
2467      composeAdverseEventPreventiveActionComponent(t, "AdverseEvent", "preventiveAction", element.getPreventiveAction().get(i), i);
2468    }
2469    for (int i = 0; i < element.getMitigatingAction().size(); i++) {
2470      composeAdverseEventMitigatingActionComponent(t, "AdverseEvent", "mitigatingAction", element.getMitigatingAction().get(i), i);
2471    }
2472    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
2473      composeAdverseEventSupportingInfoComponent(t, "AdverseEvent", "supportingInfo", element.getSupportingInfo().get(i), i);
2474    }
2475    for (int i = 0; i < element.getStudy().size(); i++) {
2476      composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i);
2477    }
2478  }
2479
2480  protected void composeAdverseEventParticipantComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventParticipantComponent element, int index) {
2481    if (element == null) 
2482      return;
2483    Complex t;
2484    if (Utilities.noString(parentType))
2485      t = parent;
2486    else {
2487      t = parent.predicate("fhir:"+parentType+'.'+name);
2488    }
2489    composeBackboneElement(t, "participant", name, element, index);
2490    if (element.hasFunction()) {
2491      composeCodeableConcept(t, "AdverseEventParticipantComponent", "function", element.getFunction(), -1);
2492    }
2493    if (element.hasActor()) {
2494      composeReference(t, "AdverseEventParticipantComponent", "actor", element.getActor(), -1);
2495    }
2496  }
2497
2498  protected void composeAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent 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, "suspectEntity", name, element, index);
2508    if (element.hasInstance()) {
2509      composeType(t, "AdverseEventSuspectEntityComponent", "instance", element.getInstance(), -1);
2510    }
2511    if (element.hasCausality()) {
2512      composeAdverseEventSuspectEntityCausalityComponent(t, "AdverseEventSuspectEntityComponent", "causality", element.getCausality(), -1);
2513    }
2514  }
2515
2516  protected void composeAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) {
2517    if (element == null) 
2518      return;
2519    Complex t;
2520    if (Utilities.noString(parentType))
2521      t = parent;
2522    else {
2523      t = parent.predicate("fhir:"+parentType+'.'+name);
2524    }
2525    composeBackboneElement(t, "causality", name, element, index);
2526    if (element.hasAssessmentMethod()) {
2527      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "assessmentMethod", element.getAssessmentMethod(), -1);
2528    }
2529    if (element.hasEntityRelatedness()) {
2530      composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "entityRelatedness", element.getEntityRelatedness(), -1);
2531    }
2532    if (element.hasAuthor()) {
2533      composeReference(t, "AdverseEventSuspectEntityCausalityComponent", "author", element.getAuthor(), -1);
2534    }
2535  }
2536
2537  protected void composeAdverseEventContributingFactorComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventContributingFactorComponent element, int index) {
2538    if (element == null) 
2539      return;
2540    Complex t;
2541    if (Utilities.noString(parentType))
2542      t = parent;
2543    else {
2544      t = parent.predicate("fhir:"+parentType+'.'+name);
2545    }
2546    composeBackboneElement(t, "contributingFactor", name, element, index);
2547    if (element.hasItem()) {
2548      composeType(t, "AdverseEventContributingFactorComponent", "item", element.getItem(), -1);
2549    }
2550  }
2551
2552  protected void composeAdverseEventPreventiveActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventPreventiveActionComponent element, int index) {
2553    if (element == null) 
2554      return;
2555    Complex t;
2556    if (Utilities.noString(parentType))
2557      t = parent;
2558    else {
2559      t = parent.predicate("fhir:"+parentType+'.'+name);
2560    }
2561    composeBackboneElement(t, "preventiveAction", name, element, index);
2562    if (element.hasItem()) {
2563      composeType(t, "AdverseEventPreventiveActionComponent", "item", element.getItem(), -1);
2564    }
2565  }
2566
2567  protected void composeAdverseEventMitigatingActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventMitigatingActionComponent element, int index) {
2568    if (element == null) 
2569      return;
2570    Complex t;
2571    if (Utilities.noString(parentType))
2572      t = parent;
2573    else {
2574      t = parent.predicate("fhir:"+parentType+'.'+name);
2575    }
2576    composeBackboneElement(t, "mitigatingAction", name, element, index);
2577    if (element.hasItem()) {
2578      composeType(t, "AdverseEventMitigatingActionComponent", "item", element.getItem(), -1);
2579    }
2580  }
2581
2582  protected void composeAdverseEventSupportingInfoComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSupportingInfoComponent 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, "supportingInfo", name, element, index);
2592    if (element.hasItem()) {
2593      composeType(t, "AdverseEventSupportingInfoComponent", "item", element.getItem(), -1);
2594    }
2595  }
2596
2597  protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) {
2598    if (element == null) 
2599      return;
2600    Complex t;
2601    if (Utilities.noString(parentType))
2602      t = parent;
2603    else {
2604      t = parent.predicate("fhir:"+parentType+'.'+name);
2605    }
2606    composeDomainResource(t, "AllergyIntolerance", name, element, index);
2607    for (int i = 0; i < element.getIdentifier().size(); i++) {
2608      composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i);
2609    }
2610    if (element.hasClinicalStatus()) {
2611      composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1);
2612    }
2613    if (element.hasVerificationStatus()) {
2614      composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1);
2615    }
2616    if (element.hasTypeElement()) {
2617      composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1);
2618    }
2619    for (int i = 0; i < element.getCategory().size(); i++) {
2620      composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i);
2621    }
2622    if (element.hasCriticalityElement()) {
2623      composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1);
2624    }
2625    if (element.hasCode()) {
2626      composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1);
2627    }
2628    if (element.hasPatient()) {
2629      composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1);
2630    }
2631    if (element.hasEncounter()) {
2632      composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1);
2633    }
2634    if (element.hasOnset()) {
2635      composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1);
2636    }
2637    if (element.hasRecordedDateElement()) {
2638      composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1);
2639    }
2640    if (element.hasRecorder()) {
2641      composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1);
2642    }
2643    if (element.hasAsserter()) {
2644      composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1);
2645    }
2646    if (element.hasLastOccurrenceElement()) {
2647      composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1);
2648    }
2649    for (int i = 0; i < element.getNote().size(); i++) {
2650      composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i);
2651    }
2652    for (int i = 0; i < element.getReaction().size(); i++) {
2653      composeAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i);
2654    }
2655  }
2656
2657  protected void composeAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) {
2658    if (element == null) 
2659      return;
2660    Complex t;
2661    if (Utilities.noString(parentType))
2662      t = parent;
2663    else {
2664      t = parent.predicate("fhir:"+parentType+'.'+name);
2665    }
2666    composeBackboneElement(t, "reaction", name, element, index);
2667    if (element.hasSubstance()) {
2668      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "substance", element.getSubstance(), -1);
2669    }
2670    for (int i = 0; i < element.getManifestation().size(); i++) {
2671      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "manifestation", element.getManifestation().get(i), i);
2672    }
2673    if (element.hasDescriptionElement()) {
2674      composeString(t, "AllergyIntoleranceReactionComponent", "description", element.getDescriptionElement(), -1);
2675    }
2676    if (element.hasOnsetElement()) {
2677      composeDateTime(t, "AllergyIntoleranceReactionComponent", "onset", element.getOnsetElement(), -1);
2678    }
2679    if (element.hasSeverityElement()) {
2680      composeEnum(t, "AllergyIntoleranceReactionComponent", "severity", element.getSeverityElement(), -1);
2681    }
2682    if (element.hasExposureRoute()) {
2683      composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "exposureRoute", element.getExposureRoute(), -1);
2684    }
2685    for (int i = 0; i < element.getNote().size(); i++) {
2686      composeAnnotation(t, "AllergyIntoleranceReactionComponent", "note", element.getNote().get(i), i);
2687    }
2688  }
2689
2690  protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) {
2691    if (element == null) 
2692      return;
2693    Complex t;
2694    if (Utilities.noString(parentType))
2695      t = parent;
2696    else {
2697      t = parent.predicate("fhir:"+parentType+'.'+name);
2698    }
2699    composeDomainResource(t, "Appointment", name, element, index);
2700    for (int i = 0; i < element.getIdentifier().size(); i++) {
2701      composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i);
2702    }
2703    if (element.hasStatusElement()) {
2704      composeEnum(t, "Appointment", "status", element.getStatusElement(), -1);
2705    }
2706    if (element.hasCancelationReason()) {
2707      composeCodeableConcept(t, "Appointment", "cancelationReason", element.getCancelationReason(), -1);
2708    }
2709    for (int i = 0; i < element.getServiceCategory().size(); i++) {
2710      composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i);
2711    }
2712    for (int i = 0; i < element.getServiceType().size(); i++) {
2713      composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i);
2714    }
2715    for (int i = 0; i < element.getSpecialty().size(); i++) {
2716      composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i);
2717    }
2718    if (element.hasAppointmentType()) {
2719      composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1);
2720    }
2721    for (int i = 0; i < element.getReason().size(); i++) {
2722      composeCodeableReference(t, "Appointment", "reason", element.getReason().get(i), i);
2723    }
2724    if (element.hasPriorityElement()) {
2725      composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1);
2726    }
2727    if (element.hasDescriptionElement()) {
2728      composeString(t, "Appointment", "description", element.getDescriptionElement(), -1);
2729    }
2730    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
2731      composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i);
2732    }
2733    if (element.hasStartElement()) {
2734      composeInstant(t, "Appointment", "start", element.getStartElement(), -1);
2735    }
2736    if (element.hasEndElement()) {
2737      composeInstant(t, "Appointment", "end", element.getEndElement(), -1);
2738    }
2739    if (element.hasMinutesDurationElement()) {
2740      composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1);
2741    }
2742    for (int i = 0; i < element.getSlot().size(); i++) {
2743      composeReference(t, "Appointment", "slot", element.getSlot().get(i), i);
2744    }
2745    if (element.hasCreatedElement()) {
2746      composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1);
2747    }
2748    if (element.hasCommentElement()) {
2749      composeString(t, "Appointment", "comment", element.getCommentElement(), -1);
2750    }
2751    if (element.hasPatientInstructionElement()) {
2752      composeString(t, "Appointment", "patientInstruction", element.getPatientInstructionElement(), -1);
2753    }
2754    for (int i = 0; i < element.getBasedOn().size(); i++) {
2755      composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i);
2756    }
2757    for (int i = 0; i < element.getParticipant().size(); i++) {
2758      composeAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i);
2759    }
2760    for (int i = 0; i < element.getRequestedPeriod().size(); i++) {
2761      composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i);
2762    }
2763  }
2764
2765  protected void composeAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) {
2766    if (element == null) 
2767      return;
2768    Complex t;
2769    if (Utilities.noString(parentType))
2770      t = parent;
2771    else {
2772      t = parent.predicate("fhir:"+parentType+'.'+name);
2773    }
2774    composeBackboneElement(t, "participant", name, element, index);
2775    for (int i = 0; i < element.getType().size(); i++) {
2776      composeCodeableConcept(t, "AppointmentParticipantComponent", "type", element.getType().get(i), i);
2777    }
2778    if (element.hasActor()) {
2779      composeReference(t, "AppointmentParticipantComponent", "actor", element.getActor(), -1);
2780    }
2781    if (element.hasRequiredElement()) {
2782      composeEnum(t, "AppointmentParticipantComponent", "required", element.getRequiredElement(), -1);
2783    }
2784    if (element.hasStatusElement()) {
2785      composeEnum(t, "AppointmentParticipantComponent", "status", element.getStatusElement(), -1);
2786    }
2787    if (element.hasPeriod()) {
2788      composePeriod(t, "AppointmentParticipantComponent", "period", element.getPeriod(), -1);
2789    }
2790  }
2791
2792  protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) {
2793    if (element == null) 
2794      return;
2795    Complex t;
2796    if (Utilities.noString(parentType))
2797      t = parent;
2798    else {
2799      t = parent.predicate("fhir:"+parentType+'.'+name);
2800    }
2801    composeDomainResource(t, "AppointmentResponse", name, element, index);
2802    for (int i = 0; i < element.getIdentifier().size(); i++) {
2803      composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i);
2804    }
2805    if (element.hasAppointment()) {
2806      composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1);
2807    }
2808    if (element.hasStartElement()) {
2809      composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1);
2810    }
2811    if (element.hasEndElement()) {
2812      composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1);
2813    }
2814    for (int i = 0; i < element.getParticipantType().size(); i++) {
2815      composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i);
2816    }
2817    if (element.hasActor()) {
2818      composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1);
2819    }
2820    if (element.hasParticipantStatusElement()) {
2821      composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1);
2822    }
2823    if (element.hasCommentElement()) {
2824      composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1);
2825    }
2826  }
2827
2828  protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) {
2829    if (element == null) 
2830      return;
2831    Complex t;
2832    if (Utilities.noString(parentType))
2833      t = parent;
2834    else {
2835      t = parent.predicate("fhir:"+parentType+'.'+name);
2836    }
2837    composeDomainResource(t, "AuditEvent", name, element, index);
2838    if (element.hasType()) {
2839      composeCoding(t, "AuditEvent", "type", element.getType(), -1);
2840    }
2841    for (int i = 0; i < element.getSubtype().size(); i++) {
2842      composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i);
2843    }
2844    if (element.hasActionElement()) {
2845      composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1);
2846    }
2847    if (element.hasSeverityElement()) {
2848      composeEnum(t, "AuditEvent", "severity", element.getSeverityElement(), -1);
2849    }
2850    if (element.hasPeriod()) {
2851      composePeriod(t, "AuditEvent", "period", element.getPeriod(), -1);
2852    }
2853    if (element.hasRecordedElement()) {
2854      composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1);
2855    }
2856    if (element.hasOutcomeElement()) {
2857      composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1);
2858    }
2859    if (element.hasOutcomeDescElement()) {
2860      composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1);
2861    }
2862    for (int i = 0; i < element.getPurposeOfEvent().size(); i++) {
2863      composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i);
2864    }
2865    for (int i = 0; i < element.getAgent().size(); i++) {
2866      composeAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i);
2867    }
2868    if (element.hasSource()) {
2869      composeAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1);
2870    }
2871    for (int i = 0; i < element.getEntity().size(); i++) {
2872      composeAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i);
2873    }
2874  }
2875
2876  protected void composeAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) {
2877    if (element == null) 
2878      return;
2879    Complex t;
2880    if (Utilities.noString(parentType))
2881      t = parent;
2882    else {
2883      t = parent.predicate("fhir:"+parentType+'.'+name);
2884    }
2885    composeBackboneElement(t, "agent", name, element, index);
2886    if (element.hasType()) {
2887      composeCodeableConcept(t, "AuditEventAgentComponent", "type", element.getType(), -1);
2888    }
2889    for (int i = 0; i < element.getRole().size(); i++) {
2890      composeCodeableConcept(t, "AuditEventAgentComponent", "role", element.getRole().get(i), i);
2891    }
2892    if (element.hasWho()) {
2893      composeReference(t, "AuditEventAgentComponent", "who", element.getWho(), -1);
2894    }
2895    if (element.hasAltIdElement()) {
2896      composeString(t, "AuditEventAgentComponent", "altId", element.getAltIdElement(), -1);
2897    }
2898    if (element.hasNameElement()) {
2899      composeString(t, "AuditEventAgentComponent", "name", element.getNameElement(), -1);
2900    }
2901    if (element.hasRequestorElement()) {
2902      composeBoolean(t, "AuditEventAgentComponent", "requestor", element.getRequestorElement(), -1);
2903    }
2904    if (element.hasLocation()) {
2905      composeReference(t, "AuditEventAgentComponent", "location", element.getLocation(), -1);
2906    }
2907    for (int i = 0; i < element.getPolicy().size(); i++) {
2908      composeUri(t, "AuditEventAgentComponent", "policy", element.getPolicy().get(i), i);
2909    }
2910    if (element.hasMedia()) {
2911      composeCoding(t, "AuditEventAgentComponent", "media", element.getMedia(), -1);
2912    }
2913    if (element.hasNetwork()) {
2914      composeAuditEventAgentNetworkComponent(t, "AuditEventAgentComponent", "network", element.getNetwork(), -1);
2915    }
2916    for (int i = 0; i < element.getPurposeOfUse().size(); i++) {
2917      composeCodeableConcept(t, "AuditEventAgentComponent", "purposeOfUse", element.getPurposeOfUse().get(i), i);
2918    }
2919  }
2920
2921  protected void composeAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) {
2922    if (element == null) 
2923      return;
2924    Complex t;
2925    if (Utilities.noString(parentType))
2926      t = parent;
2927    else {
2928      t = parent.predicate("fhir:"+parentType+'.'+name);
2929    }
2930    composeBackboneElement(t, "network", name, element, index);
2931    if (element.hasAddressElement()) {
2932      composeString(t, "AuditEventAgentNetworkComponent", "address", element.getAddressElement(), -1);
2933    }
2934    if (element.hasTypeElement()) {
2935      composeEnum(t, "AuditEventAgentNetworkComponent", "type", element.getTypeElement(), -1);
2936    }
2937  }
2938
2939  protected void composeAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) {
2940    if (element == null) 
2941      return;
2942    Complex t;
2943    if (Utilities.noString(parentType))
2944      t = parent;
2945    else {
2946      t = parent.predicate("fhir:"+parentType+'.'+name);
2947    }
2948    composeBackboneElement(t, "source", name, element, index);
2949    if (element.hasSiteElement()) {
2950      composeString(t, "AuditEventSourceComponent", "site", element.getSiteElement(), -1);
2951    }
2952    if (element.hasObserver()) {
2953      composeReference(t, "AuditEventSourceComponent", "observer", element.getObserver(), -1);
2954    }
2955    for (int i = 0; i < element.getType().size(); i++) {
2956      composeCoding(t, "AuditEventSourceComponent", "type", element.getType().get(i), i);
2957    }
2958  }
2959
2960  protected void composeAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) {
2961    if (element == null) 
2962      return;
2963    Complex t;
2964    if (Utilities.noString(parentType))
2965      t = parent;
2966    else {
2967      t = parent.predicate("fhir:"+parentType+'.'+name);
2968    }
2969    composeBackboneElement(t, "entity", name, element, index);
2970    if (element.hasWhat()) {
2971      composeReference(t, "AuditEventEntityComponent", "what", element.getWhat(), -1);
2972    }
2973    if (element.hasType()) {
2974      composeCoding(t, "AuditEventEntityComponent", "type", element.getType(), -1);
2975    }
2976    if (element.hasRole()) {
2977      composeCoding(t, "AuditEventEntityComponent", "role", element.getRole(), -1);
2978    }
2979    if (element.hasLifecycle()) {
2980      composeCoding(t, "AuditEventEntityComponent", "lifecycle", element.getLifecycle(), -1);
2981    }
2982    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
2983      composeCoding(t, "AuditEventEntityComponent", "securityLabel", element.getSecurityLabel().get(i), i);
2984    }
2985    if (element.hasNameElement()) {
2986      composeString(t, "AuditEventEntityComponent", "name", element.getNameElement(), -1);
2987    }
2988    if (element.hasQueryElement()) {
2989      composeBase64Binary(t, "AuditEventEntityComponent", "query", element.getQueryElement(), -1);
2990    }
2991    for (int i = 0; i < element.getDetail().size(); i++) {
2992      composeAuditEventEntityDetailComponent(t, "AuditEventEntityComponent", "detail", element.getDetail().get(i), i);
2993    }
2994  }
2995
2996  protected void composeAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) {
2997    if (element == null) 
2998      return;
2999    Complex t;
3000    if (Utilities.noString(parentType))
3001      t = parent;
3002    else {
3003      t = parent.predicate("fhir:"+parentType+'.'+name);
3004    }
3005    composeBackboneElement(t, "detail", name, element, index);
3006    if (element.hasTypeElement()) {
3007      composeString(t, "AuditEventEntityDetailComponent", "type", element.getTypeElement(), -1);
3008    }
3009    if (element.hasValue()) {
3010      composeType(t, "AuditEventEntityDetailComponent", "value", element.getValue(), -1);
3011    }
3012  }
3013
3014  protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) {
3015    if (element == null) 
3016      return;
3017    Complex t;
3018    if (Utilities.noString(parentType))
3019      t = parent;
3020    else {
3021      t = parent.predicate("fhir:"+parentType+'.'+name);
3022    }
3023    composeDomainResource(t, "Basic", name, element, index);
3024    for (int i = 0; i < element.getIdentifier().size(); i++) {
3025      composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i);
3026    }
3027    if (element.hasCode()) {
3028      composeCodeableConcept(t, "Basic", "code", element.getCode(), -1);
3029    }
3030    if (element.hasSubject()) {
3031      composeReference(t, "Basic", "subject", element.getSubject(), -1);
3032    }
3033    if (element.hasCreatedElement()) {
3034      composeDate(t, "Basic", "created", element.getCreatedElement(), -1);
3035    }
3036    if (element.hasAuthor()) {
3037      composeReference(t, "Basic", "author", element.getAuthor(), -1);
3038    }
3039  }
3040
3041  protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) {
3042    if (element == null) 
3043      return;
3044    Complex t;
3045    if (Utilities.noString(parentType))
3046      t = parent;
3047    else {
3048      t = parent.predicate("fhir:"+parentType+'.'+name);
3049    }
3050    composeResource(t, "Binary", name, element, index);
3051    if (element.hasContentTypeElement()) {
3052      composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1);
3053    }
3054    if (element.hasSecurityContext()) {
3055      composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1);
3056    }
3057    if (element.hasDataElement()) {
3058      composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1);
3059    }
3060  }
3061
3062  protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) {
3063    if (element == null) 
3064      return;
3065    Complex t;
3066    if (Utilities.noString(parentType))
3067      t = parent;
3068    else {
3069      t = parent.predicate("fhir:"+parentType+'.'+name);
3070    }
3071    composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index);
3072    for (int i = 0; i < element.getIdentifier().size(); i++) {
3073      composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i);
3074    }
3075    if (element.hasProductCategoryElement()) {
3076      composeEnum(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategoryElement(), -1);
3077    }
3078    if (element.hasProductCode()) {
3079      composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1);
3080    }
3081    if (element.hasStatusElement()) {
3082      composeEnum(t, "BiologicallyDerivedProduct", "status", element.getStatusElement(), -1);
3083    }
3084    for (int i = 0; i < element.getRequest().size(); i++) {
3085      composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i);
3086    }
3087    if (element.hasQuantityElement()) {
3088      composeInteger(t, "BiologicallyDerivedProduct", "quantity", element.getQuantityElement(), -1);
3089    }
3090    for (int i = 0; i < element.getParent().size(); i++) {
3091      composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i);
3092    }
3093    if (element.hasCollection()) {
3094      composeBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1);
3095    }
3096    for (int i = 0; i < element.getProcessing().size(); i++) {
3097      composeBiologicallyDerivedProductProcessingComponent(t, "BiologicallyDerivedProduct", "processing", element.getProcessing().get(i), i);
3098    }
3099    if (element.hasManipulation()) {
3100      composeBiologicallyDerivedProductManipulationComponent(t, "BiologicallyDerivedProduct", "manipulation", element.getManipulation(), -1);
3101    }
3102    for (int i = 0; i < element.getStorage().size(); i++) {
3103      composeBiologicallyDerivedProductStorageComponent(t, "BiologicallyDerivedProduct", "storage", element.getStorage().get(i), i);
3104    }
3105  }
3106
3107  protected void composeBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) {
3108    if (element == null) 
3109      return;
3110    Complex t;
3111    if (Utilities.noString(parentType))
3112      t = parent;
3113    else {
3114      t = parent.predicate("fhir:"+parentType+'.'+name);
3115    }
3116    composeBackboneElement(t, "collection", name, element, index);
3117    if (element.hasCollector()) {
3118      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "collector", element.getCollector(), -1);
3119    }
3120    if (element.hasSource()) {
3121      composeReference(t, "BiologicallyDerivedProductCollectionComponent", "source", element.getSource(), -1);
3122    }
3123    if (element.hasCollected()) {
3124      composeType(t, "BiologicallyDerivedProductCollectionComponent", "collected", element.getCollected(), -1);
3125    }
3126  }
3127
3128  protected void composeBiologicallyDerivedProductProcessingComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductProcessingComponent element, int index) {
3129    if (element == null) 
3130      return;
3131    Complex t;
3132    if (Utilities.noString(parentType))
3133      t = parent;
3134    else {
3135      t = parent.predicate("fhir:"+parentType+'.'+name);
3136    }
3137    composeBackboneElement(t, "processing", name, element, index);
3138    if (element.hasDescriptionElement()) {
3139      composeString(t, "BiologicallyDerivedProductProcessingComponent", "description", element.getDescriptionElement(), -1);
3140    }
3141    if (element.hasProcedure()) {
3142      composeCodeableConcept(t, "BiologicallyDerivedProductProcessingComponent", "procedure", element.getProcedure(), -1);
3143    }
3144    if (element.hasAdditive()) {
3145      composeReference(t, "BiologicallyDerivedProductProcessingComponent", "additive", element.getAdditive(), -1);
3146    }
3147    if (element.hasTime()) {
3148      composeType(t, "BiologicallyDerivedProductProcessingComponent", "time", element.getTime(), -1);
3149    }
3150  }
3151
3152  protected void composeBiologicallyDerivedProductManipulationComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductManipulationComponent element, int index) {
3153    if (element == null) 
3154      return;
3155    Complex t;
3156    if (Utilities.noString(parentType))
3157      t = parent;
3158    else {
3159      t = parent.predicate("fhir:"+parentType+'.'+name);
3160    }
3161    composeBackboneElement(t, "manipulation", name, element, index);
3162    if (element.hasDescriptionElement()) {
3163      composeString(t, "BiologicallyDerivedProductManipulationComponent", "description", element.getDescriptionElement(), -1);
3164    }
3165    if (element.hasTime()) {
3166      composeType(t, "BiologicallyDerivedProductManipulationComponent", "time", element.getTime(), -1);
3167    }
3168  }
3169
3170  protected void composeBiologicallyDerivedProductStorageComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductStorageComponent element, int index) {
3171    if (element == null) 
3172      return;
3173    Complex t;
3174    if (Utilities.noString(parentType))
3175      t = parent;
3176    else {
3177      t = parent.predicate("fhir:"+parentType+'.'+name);
3178    }
3179    composeBackboneElement(t, "storage", name, element, index);
3180    if (element.hasDescriptionElement()) {
3181      composeString(t, "BiologicallyDerivedProductStorageComponent", "description", element.getDescriptionElement(), -1);
3182    }
3183    if (element.hasTemperatureElement()) {
3184      composeDecimal(t, "BiologicallyDerivedProductStorageComponent", "temperature", element.getTemperatureElement(), -1);
3185    }
3186    if (element.hasScaleElement()) {
3187      composeEnum(t, "BiologicallyDerivedProductStorageComponent", "scale", element.getScaleElement(), -1);
3188    }
3189    if (element.hasDuration()) {
3190      composePeriod(t, "BiologicallyDerivedProductStorageComponent", "duration", element.getDuration(), -1);
3191    }
3192  }
3193
3194  protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) {
3195    if (element == null) 
3196      return;
3197    Complex t;
3198    if (Utilities.noString(parentType))
3199      t = parent;
3200    else {
3201      t = parent.predicate("fhir:"+parentType+'.'+name);
3202    }
3203    composeDomainResource(t, "BodyStructure", name, element, index);
3204    for (int i = 0; i < element.getIdentifier().size(); i++) {
3205      composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i);
3206    }
3207    if (element.hasActiveElement()) {
3208      composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1);
3209    }
3210    if (element.hasMorphology()) {
3211      composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1);
3212    }
3213    if (element.hasLocation()) {
3214      composeCodeableConcept(t, "BodyStructure", "location", element.getLocation(), -1);
3215    }
3216    for (int i = 0; i < element.getLocationQualifier().size(); i++) {
3217      composeCodeableConcept(t, "BodyStructure", "locationQualifier", element.getLocationQualifier().get(i), i);
3218    }
3219    if (element.hasDescriptionElement()) {
3220      composeString(t, "BodyStructure", "description", element.getDescriptionElement(), -1);
3221    }
3222    for (int i = 0; i < element.getImage().size(); i++) {
3223      composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i);
3224    }
3225    if (element.hasPatient()) {
3226      composeReference(t, "BodyStructure", "patient", element.getPatient(), -1);
3227    }
3228  }
3229
3230  protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) {
3231    if (element == null) 
3232      return;
3233    Complex t;
3234    if (Utilities.noString(parentType))
3235      t = parent;
3236    else {
3237      t = parent.predicate("fhir:"+parentType+'.'+name);
3238    }
3239    composeResource(t, "Bundle", name, element, index);
3240    if (element.hasIdentifier()) {
3241      composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1);
3242    }
3243    if (element.hasTypeElement()) {
3244      composeEnum(t, "Bundle", "type", element.getTypeElement(), -1);
3245    }
3246    if (element.hasTimestampElement()) {
3247      composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1);
3248    }
3249    if (element.hasTotalElement()) {
3250      composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1);
3251    }
3252    for (int i = 0; i < element.getLink().size(); i++) {
3253      composeBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i);
3254    }
3255    for (int i = 0; i < element.getEntry().size(); i++) {
3256      composeBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i);
3257    }
3258    if (element.hasSignature()) {
3259      composeSignature(t, "Bundle", "signature", element.getSignature(), -1);
3260    }
3261  }
3262
3263  protected void composeBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent 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, "link", name, element, index);
3273    if (element.hasRelationElement()) {
3274      composeString(t, "BundleLinkComponent", "relation", element.getRelationElement(), -1);
3275    }
3276    if (element.hasUrlElement()) {
3277      composeUri(t, "BundleLinkComponent", "url", element.getUrlElement(), -1);
3278    }
3279  }
3280
3281  protected void composeBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent 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, "entry", name, element, index);
3291    for (int i = 0; i < element.getLink().size(); i++) {
3292      composeBundleLinkComponent(t, "BundleEntryComponent", "link", element.getLink().get(i), i);
3293    }
3294    if (element.hasFullUrlElement()) {
3295      composeUri(t, "BundleEntryComponent", "fullUrl", element.getFullUrlElement(), -1);
3296    }
3297    if (element.hasResource()) {
3298      composeResource(t, "BundleEntryComponent", "resource", element.getResource(), -1);
3299    }
3300    if (element.hasSearch()) {
3301      composeBundleEntrySearchComponent(t, "BundleEntryComponent", "search", element.getSearch(), -1);
3302    }
3303    if (element.hasRequest()) {
3304      composeBundleEntryRequestComponent(t, "BundleEntryComponent", "request", element.getRequest(), -1);
3305    }
3306    if (element.hasResponse()) {
3307      composeBundleEntryResponseComponent(t, "BundleEntryComponent", "response", element.getResponse(), -1);
3308    }
3309  }
3310
3311  protected void composeBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) {
3312    if (element == null) 
3313      return;
3314    Complex t;
3315    if (Utilities.noString(parentType))
3316      t = parent;
3317    else {
3318      t = parent.predicate("fhir:"+parentType+'.'+name);
3319    }
3320    composeBackboneElement(t, "search", name, element, index);
3321    if (element.hasModeElement()) {
3322      composeEnum(t, "BundleEntrySearchComponent", "mode", element.getModeElement(), -1);
3323    }
3324    if (element.hasScoreElement()) {
3325      composeDecimal(t, "BundleEntrySearchComponent", "score", element.getScoreElement(), -1);
3326    }
3327  }
3328
3329  protected void composeBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) {
3330    if (element == null) 
3331      return;
3332    Complex t;
3333    if (Utilities.noString(parentType))
3334      t = parent;
3335    else {
3336      t = parent.predicate("fhir:"+parentType+'.'+name);
3337    }
3338    composeBackboneElement(t, "request", name, element, index);
3339    if (element.hasMethodElement()) {
3340      composeEnum(t, "BundleEntryRequestComponent", "method", element.getMethodElement(), -1);
3341    }
3342    if (element.hasUrlElement()) {
3343      composeUri(t, "BundleEntryRequestComponent", "url", element.getUrlElement(), -1);
3344    }
3345    if (element.hasIfNoneMatchElement()) {
3346      composeString(t, "BundleEntryRequestComponent", "ifNoneMatch", element.getIfNoneMatchElement(), -1);
3347    }
3348    if (element.hasIfModifiedSinceElement()) {
3349      composeInstant(t, "BundleEntryRequestComponent", "ifModifiedSince", element.getIfModifiedSinceElement(), -1);
3350    }
3351    if (element.hasIfMatchElement()) {
3352      composeString(t, "BundleEntryRequestComponent", "ifMatch", element.getIfMatchElement(), -1);
3353    }
3354    if (element.hasIfNoneExistElement()) {
3355      composeString(t, "BundleEntryRequestComponent", "ifNoneExist", element.getIfNoneExistElement(), -1);
3356    }
3357  }
3358
3359  protected void composeBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) {
3360    if (element == null) 
3361      return;
3362    Complex t;
3363    if (Utilities.noString(parentType))
3364      t = parent;
3365    else {
3366      t = parent.predicate("fhir:"+parentType+'.'+name);
3367    }
3368    composeBackboneElement(t, "response", name, element, index);
3369    if (element.hasStatusElement()) {
3370      composeString(t, "BundleEntryResponseComponent", "status", element.getStatusElement(), -1);
3371    }
3372    if (element.hasLocationElement()) {
3373      composeUri(t, "BundleEntryResponseComponent", "location", element.getLocationElement(), -1);
3374    }
3375    if (element.hasEtagElement()) {
3376      composeString(t, "BundleEntryResponseComponent", "etag", element.getEtagElement(), -1);
3377    }
3378    if (element.hasLastModifiedElement()) {
3379      composeInstant(t, "BundleEntryResponseComponent", "lastModified", element.getLastModifiedElement(), -1);
3380    }
3381    if (element.hasOutcome()) {
3382      composeResource(t, "BundleEntryResponseComponent", "outcome", element.getOutcome(), -1);
3383    }
3384  }
3385
3386  protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement 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    composeCanonicalResource(t, "CapabilityStatement", name, element, index);
3396    if (element.hasUrlElement()) {
3397      composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1);
3398    }
3399    if (element.hasVersionElement()) {
3400      composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1);
3401    }
3402    if (element.hasNameElement()) {
3403      composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1);
3404    }
3405    if (element.hasTitleElement()) {
3406      composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1);
3407    }
3408    if (element.hasStatusElement()) {
3409      composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1);
3410    }
3411    if (element.hasExperimentalElement()) {
3412      composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1);
3413    }
3414    if (element.hasDateElement()) {
3415      composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1);
3416    }
3417    if (element.hasPublisherElement()) {
3418      composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1);
3419    }
3420    for (int i = 0; i < element.getContact().size(); i++) {
3421      composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i);
3422    }
3423    if (element.hasDescriptionElement()) {
3424      composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1);
3425    }
3426    for (int i = 0; i < element.getUseContext().size(); i++) {
3427      composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i);
3428    }
3429    for (int i = 0; i < element.getJurisdiction().size(); i++) {
3430      composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i);
3431    }
3432    if (element.hasPurposeElement()) {
3433      composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1);
3434    }
3435    if (element.hasCopyrightElement()) {
3436      composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1);
3437    }
3438    if (element.hasKindElement()) {
3439      composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1);
3440    }
3441    for (int i = 0; i < element.getInstantiates().size(); i++) {
3442      composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i);
3443    }
3444    for (int i = 0; i < element.getImports().size(); i++) {
3445      composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i);
3446    }
3447    if (element.hasSoftware()) {
3448      composeCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1);
3449    }
3450    if (element.hasImplementation()) {
3451      composeCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1);
3452    }
3453    if (element.hasFhirVersionElement()) {
3454      composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1);
3455    }
3456    for (int i = 0; i < element.getFormat().size(); i++) {
3457      composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i);
3458    }
3459    for (int i = 0; i < element.getPatchFormat().size(); i++) {
3460      composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i);
3461    }
3462    for (int i = 0; i < element.getImplementationGuide().size(); i++) {
3463      composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i);
3464    }
3465    for (int i = 0; i < element.getRest().size(); i++) {
3466      composeCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i);
3467    }
3468    for (int i = 0; i < element.getMessaging().size(); i++) {
3469      composeCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i);
3470    }
3471    for (int i = 0; i < element.getDocument().size(); i++) {
3472      composeCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i);
3473    }
3474  }
3475
3476  protected void composeCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) {
3477    if (element == null) 
3478      return;
3479    Complex t;
3480    if (Utilities.noString(parentType))
3481      t = parent;
3482    else {
3483      t = parent.predicate("fhir:"+parentType+'.'+name);
3484    }
3485    composeBackboneElement(t, "software", name, element, index);
3486    if (element.hasNameElement()) {
3487      composeString(t, "CapabilityStatementSoftwareComponent", "name", element.getNameElement(), -1);
3488    }
3489    if (element.hasVersionElement()) {
3490      composeString(t, "CapabilityStatementSoftwareComponent", "version", element.getVersionElement(), -1);
3491    }
3492    if (element.hasReleaseDateElement()) {
3493      composeDateTime(t, "CapabilityStatementSoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1);
3494    }
3495  }
3496
3497  protected void composeCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) {
3498    if (element == null) 
3499      return;
3500    Complex t;
3501    if (Utilities.noString(parentType))
3502      t = parent;
3503    else {
3504      t = parent.predicate("fhir:"+parentType+'.'+name);
3505    }
3506    composeBackboneElement(t, "implementation", name, element, index);
3507    if (element.hasDescriptionElement()) {
3508      composeString(t, "CapabilityStatementImplementationComponent", "description", element.getDescriptionElement(), -1);
3509    }
3510    if (element.hasUrlElement()) {
3511      composeUrl(t, "CapabilityStatementImplementationComponent", "url", element.getUrlElement(), -1);
3512    }
3513    if (element.hasCustodian()) {
3514      composeReference(t, "CapabilityStatementImplementationComponent", "custodian", element.getCustodian(), -1);
3515    }
3516  }
3517
3518  protected void composeCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) {
3519    if (element == null) 
3520      return;
3521    Complex t;
3522    if (Utilities.noString(parentType))
3523      t = parent;
3524    else {
3525      t = parent.predicate("fhir:"+parentType+'.'+name);
3526    }
3527    composeBackboneElement(t, "rest", name, element, index);
3528    if (element.hasModeElement()) {
3529      composeEnum(t, "CapabilityStatementRestComponent", "mode", element.getModeElement(), -1);
3530    }
3531    if (element.hasDocumentationElement()) {
3532      composeMarkdown(t, "CapabilityStatementRestComponent", "documentation", element.getDocumentationElement(), -1);
3533    }
3534    if (element.hasSecurity()) {
3535      composeCapabilityStatementRestSecurityComponent(t, "CapabilityStatementRestComponent", "security", element.getSecurity(), -1);
3536    }
3537    for (int i = 0; i < element.getResource().size(); i++) {
3538      composeCapabilityStatementRestResourceComponent(t, "CapabilityStatementRestComponent", "resource", element.getResource().get(i), i);
3539    }
3540    for (int i = 0; i < element.getInteraction().size(); i++) {
3541      composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatementRestComponent", "interaction", element.getInteraction().get(i), i);
3542    }
3543    for (int i = 0; i < element.getSearchParam().size(); i++) {
3544      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestComponent", "searchParam", element.getSearchParam().get(i), i);
3545    }
3546    for (int i = 0; i < element.getOperation().size(); i++) {
3547      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestComponent", "operation", element.getOperation().get(i), i);
3548    }
3549    for (int i = 0; i < element.getCompartment().size(); i++) {
3550      composeCanonical(t, "CapabilityStatementRestComponent", "compartment", element.getCompartment().get(i), i);
3551    }
3552  }
3553
3554  protected void composeCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) {
3555    if (element == null) 
3556      return;
3557    Complex t;
3558    if (Utilities.noString(parentType))
3559      t = parent;
3560    else {
3561      t = parent.predicate("fhir:"+parentType+'.'+name);
3562    }
3563    composeBackboneElement(t, "security", name, element, index);
3564    if (element.hasCorsElement()) {
3565      composeBoolean(t, "CapabilityStatementRestSecurityComponent", "cors", element.getCorsElement(), -1);
3566    }
3567    for (int i = 0; i < element.getService().size(); i++) {
3568      composeCodeableConcept(t, "CapabilityStatementRestSecurityComponent", "service", element.getService().get(i), i);
3569    }
3570    if (element.hasDescriptionElement()) {
3571      composeMarkdown(t, "CapabilityStatementRestSecurityComponent", "description", element.getDescriptionElement(), -1);
3572    }
3573  }
3574
3575  protected void composeCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) {
3576    if (element == null) 
3577      return;
3578    Complex t;
3579    if (Utilities.noString(parentType))
3580      t = parent;
3581    else {
3582      t = parent.predicate("fhir:"+parentType+'.'+name);
3583    }
3584    composeBackboneElement(t, "resource", name, element, index);
3585    if (element.hasTypeElement()) {
3586      composeCode(t, "CapabilityStatementRestResourceComponent", "type", element.getTypeElement(), -1);
3587    }
3588    if (element.hasProfileElement()) {
3589      composeCanonical(t, "CapabilityStatementRestResourceComponent", "profile", element.getProfileElement(), -1);
3590    }
3591    for (int i = 0; i < element.getSupportedProfile().size(); i++) {
3592      composeCanonical(t, "CapabilityStatementRestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i);
3593    }
3594    if (element.hasDocumentationElement()) {
3595      composeMarkdown(t, "CapabilityStatementRestResourceComponent", "documentation", element.getDocumentationElement(), -1);
3596    }
3597    for (int i = 0; i < element.getInteraction().size(); i++) {
3598      composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatementRestResourceComponent", "interaction", element.getInteraction().get(i), i);
3599    }
3600    if (element.hasVersioningElement()) {
3601      composeEnum(t, "CapabilityStatementRestResourceComponent", "versioning", element.getVersioningElement(), -1);
3602    }
3603    if (element.hasReadHistoryElement()) {
3604      composeBoolean(t, "CapabilityStatementRestResourceComponent", "readHistory", element.getReadHistoryElement(), -1);
3605    }
3606    if (element.hasUpdateCreateElement()) {
3607      composeBoolean(t, "CapabilityStatementRestResourceComponent", "updateCreate", element.getUpdateCreateElement(), -1);
3608    }
3609    if (element.hasConditionalCreateElement()) {
3610      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalCreate", element.getConditionalCreateElement(), -1);
3611    }
3612    if (element.hasConditionalReadElement()) {
3613      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalRead", element.getConditionalReadElement(), -1);
3614    }
3615    if (element.hasConditionalUpdateElement()) {
3616      composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalUpdate", element.getConditionalUpdateElement(), -1);
3617    }
3618    if (element.hasConditionalDeleteElement()) {
3619      composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalDelete", element.getConditionalDeleteElement(), -1);
3620    }
3621    for (int i = 0; i < element.getReferencePolicy().size(); i++) {
3622      composeEnum(t, "CapabilityStatementRestResourceComponent", "referencePolicy", element.getReferencePolicy().get(i), i);
3623    }
3624    for (int i = 0; i < element.getSearchInclude().size(); i++) {
3625      composeString(t, "CapabilityStatementRestResourceComponent", "searchInclude", element.getSearchInclude().get(i), i);
3626    }
3627    for (int i = 0; i < element.getSearchRevInclude().size(); i++) {
3628      composeString(t, "CapabilityStatementRestResourceComponent", "searchRevInclude", element.getSearchRevInclude().get(i), i);
3629    }
3630    for (int i = 0; i < element.getSearchParam().size(); i++) {
3631      composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestResourceComponent", "searchParam", element.getSearchParam().get(i), i);
3632    }
3633    for (int i = 0; i < element.getOperation().size(); i++) {
3634      composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestResourceComponent", "operation", element.getOperation().get(i), i);
3635    }
3636  }
3637
3638  protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) {
3639    if (element == null) 
3640      return;
3641    Complex t;
3642    if (Utilities.noString(parentType))
3643      t = parent;
3644    else {
3645      t = parent.predicate("fhir:"+parentType+'.'+name);
3646    }
3647    composeBackboneElement(t, "interaction", name, element, index);
3648    if (element.hasCodeElement()) {
3649      composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1);
3650    }
3651    if (element.hasDocumentationElement()) {
3652      composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1);
3653    }
3654  }
3655
3656  protected void composeCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) {
3657    if (element == null) 
3658      return;
3659    Complex t;
3660    if (Utilities.noString(parentType))
3661      t = parent;
3662    else {
3663      t = parent.predicate("fhir:"+parentType+'.'+name);
3664    }
3665    composeBackboneElement(t, "searchParam", name, element, index);
3666    if (element.hasNameElement()) {
3667      composeString(t, "CapabilityStatementRestResourceSearchParamComponent", "name", element.getNameElement(), -1);
3668    }
3669    if (element.hasDefinitionElement()) {
3670      composeCanonical(t, "CapabilityStatementRestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1);
3671    }
3672    if (element.hasTypeElement()) {
3673      composeEnum(t, "CapabilityStatementRestResourceSearchParamComponent", "type", element.getTypeElement(), -1);
3674    }
3675    if (element.hasDocumentationElement()) {
3676      composeMarkdown(t, "CapabilityStatementRestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1);
3677    }
3678  }
3679
3680  protected void composeCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) {
3681    if (element == null) 
3682      return;
3683    Complex t;
3684    if (Utilities.noString(parentType))
3685      t = parent;
3686    else {
3687      t = parent.predicate("fhir:"+parentType+'.'+name);
3688    }
3689    composeBackboneElement(t, "operation", name, element, index);
3690    if (element.hasNameElement()) {
3691      composeString(t, "CapabilityStatementRestResourceOperationComponent", "name", element.getNameElement(), -1);
3692    }
3693    if (element.hasDefinitionElement()) {
3694      composeCanonical(t, "CapabilityStatementRestResourceOperationComponent", "definition", element.getDefinitionElement(), -1);
3695    }
3696    if (element.hasDocumentationElement()) {
3697      composeMarkdown(t, "CapabilityStatementRestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1);
3698    }
3699  }
3700
3701  protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) {
3702    if (element == null) 
3703      return;
3704    Complex t;
3705    if (Utilities.noString(parentType))
3706      t = parent;
3707    else {
3708      t = parent.predicate("fhir:"+parentType+'.'+name);
3709    }
3710    composeBackboneElement(t, "interaction", name, element, index);
3711    if (element.hasCodeElement()) {
3712      composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1);
3713    }
3714    if (element.hasDocumentationElement()) {
3715      composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1);
3716    }
3717  }
3718
3719  protected void composeCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) {
3720    if (element == null) 
3721      return;
3722    Complex t;
3723    if (Utilities.noString(parentType))
3724      t = parent;
3725    else {
3726      t = parent.predicate("fhir:"+parentType+'.'+name);
3727    }
3728    composeBackboneElement(t, "messaging", name, element, index);
3729    for (int i = 0; i < element.getEndpoint().size(); i++) {
3730      composeCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatementMessagingComponent", "endpoint", element.getEndpoint().get(i), i);
3731    }
3732    if (element.hasReliableCacheElement()) {
3733      composeUnsignedInt(t, "CapabilityStatementMessagingComponent", "reliableCache", element.getReliableCacheElement(), -1);
3734    }
3735    if (element.hasDocumentationElement()) {
3736      composeMarkdown(t, "CapabilityStatementMessagingComponent", "documentation", element.getDocumentationElement(), -1);
3737    }
3738    for (int i = 0; i < element.getSupportedMessage().size(); i++) {
3739      composeCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatementMessagingComponent", "supportedMessage", element.getSupportedMessage().get(i), i);
3740    }
3741  }
3742
3743  protected void composeCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) {
3744    if (element == null) 
3745      return;
3746    Complex t;
3747    if (Utilities.noString(parentType))
3748      t = parent;
3749    else {
3750      t = parent.predicate("fhir:"+parentType+'.'+name);
3751    }
3752    composeBackboneElement(t, "endpoint", name, element, index);
3753    if (element.hasProtocol()) {
3754      composeCoding(t, "CapabilityStatementMessagingEndpointComponent", "protocol", element.getProtocol(), -1);
3755    }
3756    if (element.hasAddressElement()) {
3757      composeUrl(t, "CapabilityStatementMessagingEndpointComponent", "address", element.getAddressElement(), -1);
3758    }
3759  }
3760
3761  protected void composeCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) {
3762    if (element == null) 
3763      return;
3764    Complex t;
3765    if (Utilities.noString(parentType))
3766      t = parent;
3767    else {
3768      t = parent.predicate("fhir:"+parentType+'.'+name);
3769    }
3770    composeBackboneElement(t, "supportedMessage", name, element, index);
3771    if (element.hasModeElement()) {
3772      composeEnum(t, "CapabilityStatementMessagingSupportedMessageComponent", "mode", element.getModeElement(), -1);
3773    }
3774    if (element.hasDefinitionElement()) {
3775      composeCanonical(t, "CapabilityStatementMessagingSupportedMessageComponent", "definition", element.getDefinitionElement(), -1);
3776    }
3777  }
3778
3779  protected void composeCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) {
3780    if (element == null) 
3781      return;
3782    Complex t;
3783    if (Utilities.noString(parentType))
3784      t = parent;
3785    else {
3786      t = parent.predicate("fhir:"+parentType+'.'+name);
3787    }
3788    composeBackboneElement(t, "document", name, element, index);
3789    if (element.hasModeElement()) {
3790      composeEnum(t, "CapabilityStatementDocumentComponent", "mode", element.getModeElement(), -1);
3791    }
3792    if (element.hasDocumentationElement()) {
3793      composeMarkdown(t, "CapabilityStatementDocumentComponent", "documentation", element.getDocumentationElement(), -1);
3794    }
3795    if (element.hasProfileElement()) {
3796      composeCanonical(t, "CapabilityStatementDocumentComponent", "profile", element.getProfileElement(), -1);
3797    }
3798  }
3799
3800  protected void composeCapabilityStatement2(Complex parent, String parentType, String name, CapabilityStatement2 element, int index) {
3801    if (element == null) 
3802      return;
3803    Complex t;
3804    if (Utilities.noString(parentType))
3805      t = parent;
3806    else {
3807      t = parent.predicate("fhir:"+parentType+'.'+name);
3808    }
3809    composeCanonicalResource(t, "CapabilityStatement2", name, element, index);
3810    if (element.hasUrlElement()) {
3811      composeUri(t, "CapabilityStatement2", "url", element.getUrlElement(), -1);
3812    }
3813    if (element.hasVersionElement()) {
3814      composeString(t, "CapabilityStatement2", "version", element.getVersionElement(), -1);
3815    }
3816    if (element.hasNameElement()) {
3817      composeString(t, "CapabilityStatement2", "name", element.getNameElement(), -1);
3818    }
3819    if (element.hasTitleElement()) {
3820      composeString(t, "CapabilityStatement2", "title", element.getTitleElement(), -1);
3821    }
3822    if (element.hasStatusElement()) {
3823      composeEnum(t, "CapabilityStatement2", "status", element.getStatusElement(), -1);
3824    }
3825    if (element.hasExperimentalElement()) {
3826      composeBoolean(t, "CapabilityStatement2", "experimental", element.getExperimentalElement(), -1);
3827    }
3828    if (element.hasDateElement()) {
3829      composeDateTime(t, "CapabilityStatement2", "date", element.getDateElement(), -1);
3830    }
3831    if (element.hasPublisherElement()) {
3832      composeString(t, "CapabilityStatement2", "publisher", element.getPublisherElement(), -1);
3833    }
3834    for (int i = 0; i < element.getContact().size(); i++) {
3835      composeContactDetail(t, "CapabilityStatement2", "contact", element.getContact().get(i), i);
3836    }
3837    if (element.hasDescriptionElement()) {
3838      composeMarkdown(t, "CapabilityStatement2", "description", element.getDescriptionElement(), -1);
3839    }
3840    for (int i = 0; i < element.getUseContext().size(); i++) {
3841      composeUsageContext(t, "CapabilityStatement2", "useContext", element.getUseContext().get(i), i);
3842    }
3843    for (int i = 0; i < element.getJurisdiction().size(); i++) {
3844      composeCodeableConcept(t, "CapabilityStatement2", "jurisdiction", element.getJurisdiction().get(i), i);
3845    }
3846    if (element.hasPurposeElement()) {
3847      composeMarkdown(t, "CapabilityStatement2", "purpose", element.getPurposeElement(), -1);
3848    }
3849    if (element.hasCopyrightElement()) {
3850      composeMarkdown(t, "CapabilityStatement2", "copyright", element.getCopyrightElement(), -1);
3851    }
3852    if (element.hasKindElement()) {
3853      composeEnum(t, "CapabilityStatement2", "kind", element.getKindElement(), -1);
3854    }
3855    for (int i = 0; i < element.getInstantiates().size(); i++) {
3856      composeCanonical(t, "CapabilityStatement2", "instantiates", element.getInstantiates().get(i), i);
3857    }
3858    for (int i = 0; i < element.getImports().size(); i++) {
3859      composeCanonical(t, "CapabilityStatement2", "imports", element.getImports().get(i), i);
3860    }
3861    if (element.hasSoftware()) {
3862      composeCapabilityStatement2SoftwareComponent(t, "CapabilityStatement2", "software", element.getSoftware(), -1);
3863    }
3864    if (element.hasImplementation()) {
3865      composeCapabilityStatement2ImplementationComponent(t, "CapabilityStatement2", "implementation", element.getImplementation(), -1);
3866    }
3867    if (element.hasFhirVersionElement()) {
3868      composeEnum(t, "CapabilityStatement2", "fhirVersion", element.getFhirVersionElement(), -1);
3869    }
3870    for (int i = 0; i < element.getFormat().size(); i++) {
3871      composeCode(t, "CapabilityStatement2", "format", element.getFormat().get(i), i);
3872    }
3873    for (int i = 0; i < element.getPatchFormat().size(); i++) {
3874      composeCode(t, "CapabilityStatement2", "patchFormat", element.getPatchFormat().get(i), i);
3875    }
3876    for (int i = 0; i < element.getImplementationGuide().size(); i++) {
3877      composeCanonical(t, "CapabilityStatement2", "implementationGuide", element.getImplementationGuide().get(i), i);
3878    }
3879    for (int i = 0; i < element.getRest().size(); i++) {
3880      composeCapabilityStatement2RestComponent(t, "CapabilityStatement2", "rest", element.getRest().get(i), i);
3881    }
3882  }
3883
3884  protected void composeCapabilityStatement2SoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2SoftwareComponent element, int index) {
3885    if (element == null) 
3886      return;
3887    Complex t;
3888    if (Utilities.noString(parentType))
3889      t = parent;
3890    else {
3891      t = parent.predicate("fhir:"+parentType+'.'+name);
3892    }
3893    composeBackboneElement(t, "software", name, element, index);
3894    if (element.hasNameElement()) {
3895      composeString(t, "CapabilityStatement2SoftwareComponent", "name", element.getNameElement(), -1);
3896    }
3897    if (element.hasVersionElement()) {
3898      composeString(t, "CapabilityStatement2SoftwareComponent", "version", element.getVersionElement(), -1);
3899    }
3900    if (element.hasReleaseDateElement()) {
3901      composeDateTime(t, "CapabilityStatement2SoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1);
3902    }
3903  }
3904
3905  protected void composeCapabilityStatement2ImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2ImplementationComponent element, int index) {
3906    if (element == null) 
3907      return;
3908    Complex t;
3909    if (Utilities.noString(parentType))
3910      t = parent;
3911    else {
3912      t = parent.predicate("fhir:"+parentType+'.'+name);
3913    }
3914    composeBackboneElement(t, "implementation", name, element, index);
3915    if (element.hasDescriptionElement()) {
3916      composeString(t, "CapabilityStatement2ImplementationComponent", "description", element.getDescriptionElement(), -1);
3917    }
3918    if (element.hasUrlElement()) {
3919      composeUrl(t, "CapabilityStatement2ImplementationComponent", "url", element.getUrlElement(), -1);
3920    }
3921    if (element.hasCustodian()) {
3922      composeReference(t, "CapabilityStatement2ImplementationComponent", "custodian", element.getCustodian(), -1);
3923    }
3924  }
3925
3926  protected void composeCapabilityStatement2RestComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestComponent element, int index) {
3927    if (element == null) 
3928      return;
3929    Complex t;
3930    if (Utilities.noString(parentType))
3931      t = parent;
3932    else {
3933      t = parent.predicate("fhir:"+parentType+'.'+name);
3934    }
3935    composeBackboneElement(t, "rest", name, element, index);
3936    if (element.hasModeElement()) {
3937      composeEnum(t, "CapabilityStatement2RestComponent", "mode", element.getModeElement(), -1);
3938    }
3939    if (element.hasDocumentationElement()) {
3940      composeMarkdown(t, "CapabilityStatement2RestComponent", "documentation", element.getDocumentationElement(), -1);
3941    }
3942    for (int i = 0; i < element.getResource().size(); i++) {
3943      composeCapabilityStatement2RestResourceComponent(t, "CapabilityStatement2RestComponent", "resource", element.getResource().get(i), i);
3944    }
3945    for (int i = 0; i < element.getInteraction().size(); i++) {
3946      composeCapabilityStatement2SystemInteractionComponent(t, "CapabilityStatement2RestComponent", "interaction", element.getInteraction().get(i), i);
3947    }
3948    for (int i = 0; i < element.getSearchParam().size(); i++) {
3949      composeCapabilityStatement2RestResourceSearchParamComponent(t, "CapabilityStatement2RestComponent", "searchParam", element.getSearchParam().get(i), i);
3950    }
3951    for (int i = 0; i < element.getOperation().size(); i++) {
3952      composeCapabilityStatement2RestResourceOperationComponent(t, "CapabilityStatement2RestComponent", "operation", element.getOperation().get(i), i);
3953    }
3954    for (int i = 0; i < element.getCompartment().size(); i++) {
3955      composeCanonical(t, "CapabilityStatement2RestComponent", "compartment", element.getCompartment().get(i), i);
3956    }
3957  }
3958
3959  protected void composeCapabilityStatement2RestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestResourceComponent element, int index) {
3960    if (element == null) 
3961      return;
3962    Complex t;
3963    if (Utilities.noString(parentType))
3964      t = parent;
3965    else {
3966      t = parent.predicate("fhir:"+parentType+'.'+name);
3967    }
3968    composeBackboneElement(t, "resource", name, element, index);
3969    if (element.hasTypeElement()) {
3970      composeCode(t, "CapabilityStatement2RestResourceComponent", "type", element.getTypeElement(), -1);
3971    }
3972    if (element.hasProfileElement()) {
3973      composeCanonical(t, "CapabilityStatement2RestResourceComponent", "profile", element.getProfileElement(), -1);
3974    }
3975    for (int i = 0; i < element.getSupportedProfile().size(); i++) {
3976      composeCanonical(t, "CapabilityStatement2RestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i);
3977    }
3978    if (element.hasDocumentationElement()) {
3979      composeMarkdown(t, "CapabilityStatement2RestResourceComponent", "documentation", element.getDocumentationElement(), -1);
3980    }
3981    for (int i = 0; i < element.getInteraction().size(); i++) {
3982      composeCapabilityStatement2ResourceInteractionComponent(t, "CapabilityStatement2RestResourceComponent", "interaction", element.getInteraction().get(i), i);
3983    }
3984    for (int i = 0; i < element.getSearchParam().size(); i++) {
3985      composeCapabilityStatement2RestResourceSearchParamComponent(t, "CapabilityStatement2RestResourceComponent", "searchParam", element.getSearchParam().get(i), i);
3986    }
3987    for (int i = 0; i < element.getOperation().size(); i++) {
3988      composeCapabilityStatement2RestResourceOperationComponent(t, "CapabilityStatement2RestResourceComponent", "operation", element.getOperation().get(i), i);
3989    }
3990  }
3991
3992  protected void composeCapabilityStatement2ResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement2.ResourceInteractionComponent 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    composeBackboneElement(t, "interaction", name, element, index);
4002    if (element.hasCodeElement()) {
4003      composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1);
4004    }
4005    if (element.hasDocumentationElement()) {
4006      composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1);
4007    }
4008  }
4009
4010  protected void composeCapabilityStatement2RestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestResourceSearchParamComponent element, int index) {
4011    if (element == null) 
4012      return;
4013    Complex t;
4014    if (Utilities.noString(parentType))
4015      t = parent;
4016    else {
4017      t = parent.predicate("fhir:"+parentType+'.'+name);
4018    }
4019    composeBackboneElement(t, "searchParam", name, element, index);
4020    if (element.hasNameElement()) {
4021      composeString(t, "CapabilityStatement2RestResourceSearchParamComponent", "name", element.getNameElement(), -1);
4022    }
4023    if (element.hasDefinitionElement()) {
4024      composeCanonical(t, "CapabilityStatement2RestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1);
4025    }
4026    if (element.hasTypeElement()) {
4027      composeEnum(t, "CapabilityStatement2RestResourceSearchParamComponent", "type", element.getTypeElement(), -1);
4028    }
4029    if (element.hasDocumentationElement()) {
4030      composeMarkdown(t, "CapabilityStatement2RestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1);
4031    }
4032  }
4033
4034  protected void composeCapabilityStatement2RestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestResourceOperationComponent element, int index) {
4035    if (element == null) 
4036      return;
4037    Complex t;
4038    if (Utilities.noString(parentType))
4039      t = parent;
4040    else {
4041      t = parent.predicate("fhir:"+parentType+'.'+name);
4042    }
4043    composeBackboneElement(t, "operation", name, element, index);
4044    if (element.hasNameElement()) {
4045      composeString(t, "CapabilityStatement2RestResourceOperationComponent", "name", element.getNameElement(), -1);
4046    }
4047    if (element.hasDefinitionElement()) {
4048      composeCanonical(t, "CapabilityStatement2RestResourceOperationComponent", "definition", element.getDefinitionElement(), -1);
4049    }
4050    if (element.hasDocumentationElement()) {
4051      composeMarkdown(t, "CapabilityStatement2RestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1);
4052    }
4053  }
4054
4055  protected void composeCapabilityStatement2SystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement2.SystemInteractionComponent element, int index) {
4056    if (element == null) 
4057      return;
4058    Complex t;
4059    if (Utilities.noString(parentType))
4060      t = parent;
4061    else {
4062      t = parent.predicate("fhir:"+parentType+'.'+name);
4063    }
4064    composeBackboneElement(t, "interaction", name, element, index);
4065    if (element.hasCodeElement()) {
4066      composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1);
4067    }
4068    if (element.hasDocumentationElement()) {
4069      composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1);
4070    }
4071  }
4072
4073  protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) {
4074    if (element == null) 
4075      return;
4076    Complex t;
4077    if (Utilities.noString(parentType))
4078      t = parent;
4079    else {
4080      t = parent.predicate("fhir:"+parentType+'.'+name);
4081    }
4082    composeDomainResource(t, "CarePlan", name, element, index);
4083    for (int i = 0; i < element.getIdentifier().size(); i++) {
4084      composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i);
4085    }
4086    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
4087      composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
4088    }
4089    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
4090      composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i);
4091    }
4092    for (int i = 0; i < element.getBasedOn().size(); i++) {
4093      composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i);
4094    }
4095    for (int i = 0; i < element.getReplaces().size(); i++) {
4096      composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i);
4097    }
4098    for (int i = 0; i < element.getPartOf().size(); i++) {
4099      composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i);
4100    }
4101    if (element.hasStatusElement()) {
4102      composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1);
4103    }
4104    if (element.hasIntentElement()) {
4105      composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1);
4106    }
4107    for (int i = 0; i < element.getCategory().size(); i++) {
4108      composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i);
4109    }
4110    if (element.hasTitleElement()) {
4111      composeString(t, "CarePlan", "title", element.getTitleElement(), -1);
4112    }
4113    if (element.hasDescriptionElement()) {
4114      composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1);
4115    }
4116    if (element.hasSubject()) {
4117      composeReference(t, "CarePlan", "subject", element.getSubject(), -1);
4118    }
4119    if (element.hasEncounter()) {
4120      composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1);
4121    }
4122    if (element.hasPeriod()) {
4123      composePeriod(t, "CarePlan", "period", element.getPeriod(), -1);
4124    }
4125    if (element.hasCreatedElement()) {
4126      composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1);
4127    }
4128    if (element.hasAuthor()) {
4129      composeReference(t, "CarePlan", "author", element.getAuthor(), -1);
4130    }
4131    for (int i = 0; i < element.getContributor().size(); i++) {
4132      composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i);
4133    }
4134    for (int i = 0; i < element.getCareTeam().size(); i++) {
4135      composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i);
4136    }
4137    for (int i = 0; i < element.getAddresses().size(); i++) {
4138      composeCodeableReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i);
4139    }
4140    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
4141      composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i);
4142    }
4143    for (int i = 0; i < element.getGoal().size(); i++) {
4144      composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i);
4145    }
4146    for (int i = 0; i < element.getActivity().size(); i++) {
4147      composeCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i);
4148    }
4149    for (int i = 0; i < element.getNote().size(); i++) {
4150      composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i);
4151    }
4152  }
4153
4154  protected void composeCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) {
4155    if (element == null) 
4156      return;
4157    Complex t;
4158    if (Utilities.noString(parentType))
4159      t = parent;
4160    else {
4161      t = parent.predicate("fhir:"+parentType+'.'+name);
4162    }
4163    composeBackboneElement(t, "activity", name, element, index);
4164    for (int i = 0; i < element.getOutcome().size(); i++) {
4165      composeCodeableReference(t, "CarePlanActivityComponent", "outcome", element.getOutcome().get(i), i);
4166    }
4167    for (int i = 0; i < element.getProgress().size(); i++) {
4168      composeAnnotation(t, "CarePlanActivityComponent", "progress", element.getProgress().get(i), i);
4169    }
4170    if (element.hasReference()) {
4171      composeReference(t, "CarePlanActivityComponent", "reference", element.getReference(), -1);
4172    }
4173    if (element.hasDetail()) {
4174      composeCarePlanActivityDetailComponent(t, "CarePlanActivityComponent", "detail", element.getDetail(), -1);
4175    }
4176  }
4177
4178  protected void composeCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) {
4179    if (element == null) 
4180      return;
4181    Complex t;
4182    if (Utilities.noString(parentType))
4183      t = parent;
4184    else {
4185      t = parent.predicate("fhir:"+parentType+'.'+name);
4186    }
4187    composeBackboneElement(t, "detail", name, element, index);
4188    if (element.hasKindElement()) {
4189      composeEnum(t, "CarePlanActivityDetailComponent", "kind", element.getKindElement(), -1);
4190    }
4191    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
4192      composeCanonical(t, "CarePlanActivityDetailComponent", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
4193    }
4194    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
4195      composeUri(t, "CarePlanActivityDetailComponent", "instantiatesUri", element.getInstantiatesUri().get(i), i);
4196    }
4197    if (element.hasCode()) {
4198      composeCodeableConcept(t, "CarePlanActivityDetailComponent", "code", element.getCode(), -1);
4199    }
4200    for (int i = 0; i < element.getReason().size(); i++) {
4201      composeCodeableReference(t, "CarePlanActivityDetailComponent", "reason", element.getReason().get(i), i);
4202    }
4203    for (int i = 0; i < element.getGoal().size(); i++) {
4204      composeReference(t, "CarePlanActivityDetailComponent", "goal", element.getGoal().get(i), i);
4205    }
4206    if (element.hasStatusElement()) {
4207      composeEnum(t, "CarePlanActivityDetailComponent", "status", element.getStatusElement(), -1);
4208    }
4209    if (element.hasStatusReason()) {
4210      composeCodeableConcept(t, "CarePlanActivityDetailComponent", "statusReason", element.getStatusReason(), -1);
4211    }
4212    if (element.hasDoNotPerformElement()) {
4213      composeBoolean(t, "CarePlanActivityDetailComponent", "doNotPerform", element.getDoNotPerformElement(), -1);
4214    }
4215    if (element.hasScheduled()) {
4216      composeType(t, "CarePlanActivityDetailComponent", "scheduled", element.getScheduled(), -1);
4217    }
4218    if (element.hasLocation()) {
4219      composeReference(t, "CarePlanActivityDetailComponent", "location", element.getLocation(), -1);
4220    }
4221    if (element.hasReported()) {
4222      composeType(t, "CarePlanActivityDetailComponent", "reported", element.getReported(), -1);
4223    }
4224    for (int i = 0; i < element.getPerformer().size(); i++) {
4225      composeReference(t, "CarePlanActivityDetailComponent", "performer", element.getPerformer().get(i), i);
4226    }
4227    if (element.hasProduct()) {
4228      composeType(t, "CarePlanActivityDetailComponent", "product", element.getProduct(), -1);
4229    }
4230    if (element.hasDailyAmount()) {
4231      composeQuantity(t, "CarePlanActivityDetailComponent", "dailyAmount", element.getDailyAmount(), -1);
4232    }
4233    if (element.hasQuantity()) {
4234      composeQuantity(t, "CarePlanActivityDetailComponent", "quantity", element.getQuantity(), -1);
4235    }
4236    if (element.hasDescriptionElement()) {
4237      composeString(t, "CarePlanActivityDetailComponent", "description", element.getDescriptionElement(), -1);
4238    }
4239  }
4240
4241  protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) {
4242    if (element == null) 
4243      return;
4244    Complex t;
4245    if (Utilities.noString(parentType))
4246      t = parent;
4247    else {
4248      t = parent.predicate("fhir:"+parentType+'.'+name);
4249    }
4250    composeDomainResource(t, "CareTeam", name, element, index);
4251    for (int i = 0; i < element.getIdentifier().size(); i++) {
4252      composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i);
4253    }
4254    if (element.hasStatusElement()) {
4255      composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1);
4256    }
4257    for (int i = 0; i < element.getCategory().size(); i++) {
4258      composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i);
4259    }
4260    if (element.hasNameElement()) {
4261      composeString(t, "CareTeam", "name", element.getNameElement(), -1);
4262    }
4263    if (element.hasSubject()) {
4264      composeReference(t, "CareTeam", "subject", element.getSubject(), -1);
4265    }
4266    if (element.hasPeriod()) {
4267      composePeriod(t, "CareTeam", "period", element.getPeriod(), -1);
4268    }
4269    for (int i = 0; i < element.getParticipant().size(); i++) {
4270      composeCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i);
4271    }
4272    for (int i = 0; i < element.getReason().size(); i++) {
4273      composeCodeableReference(t, "CareTeam", "reason", element.getReason().get(i), i);
4274    }
4275    for (int i = 0; i < element.getManagingOrganization().size(); i++) {
4276      composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i);
4277    }
4278    for (int i = 0; i < element.getTelecom().size(); i++) {
4279      composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i);
4280    }
4281    for (int i = 0; i < element.getNote().size(); i++) {
4282      composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i);
4283    }
4284  }
4285
4286  protected void composeCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) {
4287    if (element == null) 
4288      return;
4289    Complex t;
4290    if (Utilities.noString(parentType))
4291      t = parent;
4292    else {
4293      t = parent.predicate("fhir:"+parentType+'.'+name);
4294    }
4295    composeBackboneElement(t, "participant", name, element, index);
4296    if (element.hasRole()) {
4297      composeCodeableConcept(t, "CareTeamParticipantComponent", "role", element.getRole(), -1);
4298    }
4299    if (element.hasMember()) {
4300      composeReference(t, "CareTeamParticipantComponent", "member", element.getMember(), -1);
4301    }
4302    if (element.hasOnBehalfOf()) {
4303      composeReference(t, "CareTeamParticipantComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
4304    }
4305    if (element.hasCoverage()) {
4306      composeType(t, "CareTeamParticipantComponent", "coverage", element.getCoverage(), -1);
4307    }
4308  }
4309
4310  protected void composeCatalogEntry(Complex parent, String parentType, String name, CatalogEntry element, int index) {
4311    if (element == null) 
4312      return;
4313    Complex t;
4314    if (Utilities.noString(parentType))
4315      t = parent;
4316    else {
4317      t = parent.predicate("fhir:"+parentType+'.'+name);
4318    }
4319    composeDomainResource(t, "CatalogEntry", name, element, index);
4320    for (int i = 0; i < element.getIdentifier().size(); i++) {
4321      composeIdentifier(t, "CatalogEntry", "identifier", element.getIdentifier().get(i), i);
4322    }
4323    if (element.hasNameElement()) {
4324      composeString(t, "CatalogEntry", "name", element.getNameElement(), -1);
4325    }
4326    if (element.hasTypeElement()) {
4327      composeEnum(t, "CatalogEntry", "type", element.getTypeElement(), -1);
4328    }
4329    if (element.hasStatusElement()) {
4330      composeEnum(t, "CatalogEntry", "status", element.getStatusElement(), -1);
4331    }
4332    if (element.hasEffectivePeriod()) {
4333      composePeriod(t, "CatalogEntry", "effectivePeriod", element.getEffectivePeriod(), -1);
4334    }
4335    if (element.hasOrderableElement()) {
4336      composeBoolean(t, "CatalogEntry", "orderable", element.getOrderableElement(), -1);
4337    }
4338    if (element.hasReferencedItem()) {
4339      composeReference(t, "CatalogEntry", "referencedItem", element.getReferencedItem(), -1);
4340    }
4341    for (int i = 0; i < element.getRelatedEntry().size(); i++) {
4342      composeCatalogEntryRelatedEntryComponent(t, "CatalogEntry", "relatedEntry", element.getRelatedEntry().get(i), i);
4343    }
4344    if (element.hasUpdatedBy()) {
4345      composeReference(t, "CatalogEntry", "updatedBy", element.getUpdatedBy(), -1);
4346    }
4347    for (int i = 0; i < element.getNote().size(); i++) {
4348      composeAnnotation(t, "CatalogEntry", "note", element.getNote().get(i), i);
4349    }
4350    if (element.hasEstimatedDuration()) {
4351      composeDuration(t, "CatalogEntry", "estimatedDuration", element.getEstimatedDuration(), -1);
4352    }
4353    for (int i = 0; i < element.getBillingCode().size(); i++) {
4354      composeCodeableConcept(t, "CatalogEntry", "billingCode", element.getBillingCode().get(i), i);
4355    }
4356    if (element.hasBillingSummaryElement()) {
4357      composeString(t, "CatalogEntry", "billingSummary", element.getBillingSummaryElement(), -1);
4358    }
4359    if (element.hasScheduleSummaryElement()) {
4360      composeString(t, "CatalogEntry", "scheduleSummary", element.getScheduleSummaryElement(), -1);
4361    }
4362    if (element.hasLimitationSummaryElement()) {
4363      composeString(t, "CatalogEntry", "limitationSummary", element.getLimitationSummaryElement(), -1);
4364    }
4365    if (element.hasRegulatorySummaryElement()) {
4366      composeString(t, "CatalogEntry", "regulatorySummary", element.getRegulatorySummaryElement(), -1);
4367    }
4368  }
4369
4370  protected void composeCatalogEntryRelatedEntryComponent(Complex parent, String parentType, String name, CatalogEntry.CatalogEntryRelatedEntryComponent element, int index) {
4371    if (element == null) 
4372      return;
4373    Complex t;
4374    if (Utilities.noString(parentType))
4375      t = parent;
4376    else {
4377      t = parent.predicate("fhir:"+parentType+'.'+name);
4378    }
4379    composeBackboneElement(t, "relatedEntry", name, element, index);
4380    if (element.hasRelationshipElement()) {
4381      composeEnum(t, "CatalogEntryRelatedEntryComponent", "relationship", element.getRelationshipElement(), -1);
4382    }
4383    if (element.hasTarget()) {
4384      composeReference(t, "CatalogEntryRelatedEntryComponent", "target", element.getTarget(), -1);
4385    }
4386  }
4387
4388  protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) {
4389    if (element == null) 
4390      return;
4391    Complex t;
4392    if (Utilities.noString(parentType))
4393      t = parent;
4394    else {
4395      t = parent.predicate("fhir:"+parentType+'.'+name);
4396    }
4397    composeDomainResource(t, "ChargeItem", name, element, index);
4398    for (int i = 0; i < element.getIdentifier().size(); i++) {
4399      composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i);
4400    }
4401    for (int i = 0; i < element.getDefinitionUri().size(); i++) {
4402      composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i);
4403    }
4404    for (int i = 0; i < element.getDefinitionCanonical().size(); i++) {
4405      composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i);
4406    }
4407    if (element.hasStatusElement()) {
4408      composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1);
4409    }
4410    for (int i = 0; i < element.getPartOf().size(); i++) {
4411      composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i);
4412    }
4413    if (element.hasCode()) {
4414      composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1);
4415    }
4416    if (element.hasSubject()) {
4417      composeReference(t, "ChargeItem", "subject", element.getSubject(), -1);
4418    }
4419    if (element.hasContext()) {
4420      composeReference(t, "ChargeItem", "context", element.getContext(), -1);
4421    }
4422    if (element.hasOccurrence()) {
4423      composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1);
4424    }
4425    for (int i = 0; i < element.getPerformer().size(); i++) {
4426      composeChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i);
4427    }
4428    if (element.hasPerformingOrganization()) {
4429      composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1);
4430    }
4431    if (element.hasRequestingOrganization()) {
4432      composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1);
4433    }
4434    if (element.hasCostCenter()) {
4435      composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1);
4436    }
4437    if (element.hasQuantity()) {
4438      composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1);
4439    }
4440    for (int i = 0; i < element.getBodysite().size(); i++) {
4441      composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i);
4442    }
4443    if (element.hasFactorOverrideElement()) {
4444      composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1);
4445    }
4446    if (element.hasPriceOverride()) {
4447      composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1);
4448    }
4449    if (element.hasOverrideReasonElement()) {
4450      composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1);
4451    }
4452    if (element.hasEnterer()) {
4453      composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1);
4454    }
4455    if (element.hasEnteredDateElement()) {
4456      composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1);
4457    }
4458    for (int i = 0; i < element.getReason().size(); i++) {
4459      composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i);
4460    }
4461    for (int i = 0; i < element.getService().size(); i++) {
4462      composeReference(t, "ChargeItem", "service", element.getService().get(i), i);
4463    }
4464    if (element.hasProduct()) {
4465      composeType(t, "ChargeItem", "product", element.getProduct(), -1);
4466    }
4467    for (int i = 0; i < element.getAccount().size(); i++) {
4468      composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i);
4469    }
4470    for (int i = 0; i < element.getNote().size(); i++) {
4471      composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i);
4472    }
4473    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
4474      composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i);
4475    }
4476  }
4477
4478  protected void composeChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent 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, "performer", name, element, index);
4488    if (element.hasFunction()) {
4489      composeCodeableConcept(t, "ChargeItemPerformerComponent", "function", element.getFunction(), -1);
4490    }
4491    if (element.hasActor()) {
4492      composeReference(t, "ChargeItemPerformerComponent", "actor", element.getActor(), -1);
4493    }
4494  }
4495
4496  protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition element, int index) {
4497    if (element == null) 
4498      return;
4499    Complex t;
4500    if (Utilities.noString(parentType))
4501      t = parent;
4502    else {
4503      t = parent.predicate("fhir:"+parentType+'.'+name);
4504    }
4505    composeMetadataResource(t, "ChargeItemDefinition", name, element, index);
4506    if (element.hasUrlElement()) {
4507      composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1);
4508    }
4509    for (int i = 0; i < element.getIdentifier().size(); i++) {
4510      composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i);
4511    }
4512    if (element.hasVersionElement()) {
4513      composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1);
4514    }
4515    if (element.hasTitleElement()) {
4516      composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1);
4517    }
4518    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
4519      composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
4520    }
4521    for (int i = 0; i < element.getPartOf().size(); i++) {
4522      composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i);
4523    }
4524    for (int i = 0; i < element.getReplaces().size(); i++) {
4525      composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i);
4526    }
4527    if (element.hasStatusElement()) {
4528      composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1);
4529    }
4530    if (element.hasExperimentalElement()) {
4531      composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1);
4532    }
4533    if (element.hasDateElement()) {
4534      composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1);
4535    }
4536    if (element.hasPublisherElement()) {
4537      composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1);
4538    }
4539    for (int i = 0; i < element.getContact().size(); i++) {
4540      composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i);
4541    }
4542    if (element.hasDescriptionElement()) {
4543      composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1);
4544    }
4545    for (int i = 0; i < element.getUseContext().size(); i++) {
4546      composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i);
4547    }
4548    for (int i = 0; i < element.getJurisdiction().size(); i++) {
4549      composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
4550    }
4551    if (element.hasCopyrightElement()) {
4552      composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1);
4553    }
4554    if (element.hasApprovalDateElement()) {
4555      composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1);
4556    }
4557    if (element.hasLastReviewDateElement()) {
4558      composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
4559    }
4560    if (element.hasEffectivePeriod()) {
4561      composePeriod(t, "ChargeItemDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
4562    }
4563    if (element.hasCode()) {
4564      composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1);
4565    }
4566    for (int i = 0; i < element.getInstance().size(); i++) {
4567      composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i);
4568    }
4569    for (int i = 0; i < element.getApplicability().size(); i++) {
4570      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i);
4571    }
4572    for (int i = 0; i < element.getPropertyGroup().size(); i++) {
4573      composeChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i);
4574    }
4575  }
4576
4577  protected void composeChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent element, int index) {
4578    if (element == null) 
4579      return;
4580    Complex t;
4581    if (Utilities.noString(parentType))
4582      t = parent;
4583    else {
4584      t = parent.predicate("fhir:"+parentType+'.'+name);
4585    }
4586    composeBackboneElement(t, "applicability", name, element, index);
4587    if (element.hasDescriptionElement()) {
4588      composeString(t, "ChargeItemDefinitionApplicabilityComponent", "description", element.getDescriptionElement(), -1);
4589    }
4590    if (element.hasLanguageElement()) {
4591      composeString(t, "ChargeItemDefinitionApplicabilityComponent", "language", element.getLanguageElement(), -1);
4592    }
4593    if (element.hasExpressionElement()) {
4594      composeString(t, "ChargeItemDefinitionApplicabilityComponent", "expression", element.getExpressionElement(), -1);
4595    }
4596  }
4597
4598  protected void composeChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) {
4599    if (element == null) 
4600      return;
4601    Complex t;
4602    if (Utilities.noString(parentType))
4603      t = parent;
4604    else {
4605      t = parent.predicate("fhir:"+parentType+'.'+name);
4606    }
4607    composeBackboneElement(t, "propertyGroup", name, element, index);
4608    for (int i = 0; i < element.getApplicability().size(); i++) {
4609      composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "applicability", element.getApplicability().get(i), i);
4610    }
4611    for (int i = 0; i < element.getPriceComponent().size(); i++) {
4612      composeChargeItemDefinitionPropertyGroupPriceComponentComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "priceComponent", element.getPriceComponent().get(i), i);
4613    }
4614  }
4615
4616  protected void composeChargeItemDefinitionPropertyGroupPriceComponentComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupPriceComponentComponent 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, "priceComponent", name, element, index);
4626    if (element.hasTypeElement()) {
4627      composeEnum(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "type", element.getTypeElement(), -1);
4628    }
4629    if (element.hasCode()) {
4630      composeCodeableConcept(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "code", element.getCode(), -1);
4631    }
4632    if (element.hasFactorElement()) {
4633      composeDecimal(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "factor", element.getFactorElement(), -1);
4634    }
4635    if (element.hasAmount()) {
4636      composeMoney(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "amount", element.getAmount(), -1);
4637    }
4638  }
4639
4640  protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) {
4641    if (element == null) 
4642      return;
4643    Complex t;
4644    if (Utilities.noString(parentType))
4645      t = parent;
4646    else {
4647      t = parent.predicate("fhir:"+parentType+'.'+name);
4648    }
4649    composeDomainResource(t, "Claim", name, element, index);
4650    for (int i = 0; i < element.getIdentifier().size(); i++) {
4651      composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i);
4652    }
4653    if (element.hasStatusElement()) {
4654      composeEnum(t, "Claim", "status", element.getStatusElement(), -1);
4655    }
4656    if (element.hasType()) {
4657      composeCodeableConcept(t, "Claim", "type", element.getType(), -1);
4658    }
4659    if (element.hasSubType()) {
4660      composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1);
4661    }
4662    if (element.hasUseElement()) {
4663      composeEnum(t, "Claim", "use", element.getUseElement(), -1);
4664    }
4665    if (element.hasPatient()) {
4666      composeReference(t, "Claim", "patient", element.getPatient(), -1);
4667    }
4668    if (element.hasBillablePeriod()) {
4669      composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1);
4670    }
4671    if (element.hasCreatedElement()) {
4672      composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1);
4673    }
4674    if (element.hasEnterer()) {
4675      composeReference(t, "Claim", "enterer", element.getEnterer(), -1);
4676    }
4677    if (element.hasInsurer()) {
4678      composeReference(t, "Claim", "insurer", element.getInsurer(), -1);
4679    }
4680    if (element.hasProvider()) {
4681      composeReference(t, "Claim", "provider", element.getProvider(), -1);
4682    }
4683    if (element.hasPriority()) {
4684      composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1);
4685    }
4686    if (element.hasFundsReserve()) {
4687      composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1);
4688    }
4689    for (int i = 0; i < element.getRelated().size(); i++) {
4690      composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i);
4691    }
4692    if (element.hasPrescription()) {
4693      composeReference(t, "Claim", "prescription", element.getPrescription(), -1);
4694    }
4695    if (element.hasOriginalPrescription()) {
4696      composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1);
4697    }
4698    if (element.hasPayee()) {
4699      composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1);
4700    }
4701    if (element.hasReferral()) {
4702      composeReference(t, "Claim", "referral", element.getReferral(), -1);
4703    }
4704    if (element.hasFacility()) {
4705      composeReference(t, "Claim", "facility", element.getFacility(), -1);
4706    }
4707    for (int i = 0; i < element.getCareTeam().size(); i++) {
4708      composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i);
4709    }
4710    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
4711      composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i);
4712    }
4713    for (int i = 0; i < element.getDiagnosis().size(); i++) {
4714      composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i);
4715    }
4716    for (int i = 0; i < element.getProcedure().size(); i++) {
4717      composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i);
4718    }
4719    for (int i = 0; i < element.getInsurance().size(); i++) {
4720      composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i);
4721    }
4722    if (element.hasAccident()) {
4723      composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1);
4724    }
4725    for (int i = 0; i < element.getItem().size(); i++) {
4726      composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i);
4727    }
4728    if (element.hasTotal()) {
4729      composeMoney(t, "Claim", "total", element.getTotal(), -1);
4730    }
4731  }
4732
4733  protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) {
4734    if (element == null) 
4735      return;
4736    Complex t;
4737    if (Utilities.noString(parentType))
4738      t = parent;
4739    else {
4740      t = parent.predicate("fhir:"+parentType+'.'+name);
4741    }
4742    composeBackboneElement(t, "related", name, element, index);
4743    if (element.hasClaim()) {
4744      composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1);
4745    }
4746    if (element.hasRelationship()) {
4747      composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1);
4748    }
4749    if (element.hasReference()) {
4750      composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1);
4751    }
4752  }
4753
4754  protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) {
4755    if (element == null) 
4756      return;
4757    Complex t;
4758    if (Utilities.noString(parentType))
4759      t = parent;
4760    else {
4761      t = parent.predicate("fhir:"+parentType+'.'+name);
4762    }
4763    composeBackboneElement(t, "payee", name, element, index);
4764    if (element.hasType()) {
4765      composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1);
4766    }
4767    if (element.hasParty()) {
4768      composeReference(t, "PayeeComponent", "party", element.getParty(), -1);
4769    }
4770  }
4771
4772  protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent 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, "careTeam", name, element, index);
4782    if (element.hasSequenceElement()) {
4783      composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1);
4784    }
4785    if (element.hasProvider()) {
4786      composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1);
4787    }
4788    if (element.hasResponsibleElement()) {
4789      composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1);
4790    }
4791    if (element.hasRole()) {
4792      composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1);
4793    }
4794    if (element.hasQualification()) {
4795      composeCodeableConcept(t, "CareTeamComponent", "qualification", element.getQualification(), -1);
4796    }
4797  }
4798
4799  protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) {
4800    if (element == null) 
4801      return;
4802    Complex t;
4803    if (Utilities.noString(parentType))
4804      t = parent;
4805    else {
4806      t = parent.predicate("fhir:"+parentType+'.'+name);
4807    }
4808    composeBackboneElement(t, "supportingInfo", name, element, index);
4809    if (element.hasSequenceElement()) {
4810      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
4811    }
4812    if (element.hasCategory()) {
4813      composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1);
4814    }
4815    if (element.hasCode()) {
4816      composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1);
4817    }
4818    if (element.hasTiming()) {
4819      composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1);
4820    }
4821    if (element.hasValue()) {
4822      composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1);
4823    }
4824    if (element.hasReason()) {
4825      composeCodeableConcept(t, "SupportingInformationComponent", "reason", element.getReason(), -1);
4826    }
4827  }
4828
4829  protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) {
4830    if (element == null) 
4831      return;
4832    Complex t;
4833    if (Utilities.noString(parentType))
4834      t = parent;
4835    else {
4836      t = parent.predicate("fhir:"+parentType+'.'+name);
4837    }
4838    composeBackboneElement(t, "diagnosis", name, element, index);
4839    if (element.hasSequenceElement()) {
4840      composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1);
4841    }
4842    if (element.hasDiagnosis()) {
4843      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
4844    }
4845    for (int i = 0; i < element.getType().size(); i++) {
4846      composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i);
4847    }
4848    if (element.hasOnAdmission()) {
4849      composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1);
4850    }
4851    if (element.hasPackageCode()) {
4852      composeCodeableConcept(t, "DiagnosisComponent", "packageCode", element.getPackageCode(), -1);
4853    }
4854  }
4855
4856  protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) {
4857    if (element == null) 
4858      return;
4859    Complex t;
4860    if (Utilities.noString(parentType))
4861      t = parent;
4862    else {
4863      t = parent.predicate("fhir:"+parentType+'.'+name);
4864    }
4865    composeBackboneElement(t, "procedure", name, element, index);
4866    if (element.hasSequenceElement()) {
4867      composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1);
4868    }
4869    for (int i = 0; i < element.getType().size(); i++) {
4870      composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i);
4871    }
4872    if (element.hasDateElement()) {
4873      composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1);
4874    }
4875    if (element.hasProcedure()) {
4876      composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1);
4877    }
4878    for (int i = 0; i < element.getUdi().size(); i++) {
4879      composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i);
4880    }
4881  }
4882
4883  protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) {
4884    if (element == null) 
4885      return;
4886    Complex t;
4887    if (Utilities.noString(parentType))
4888      t = parent;
4889    else {
4890      t = parent.predicate("fhir:"+parentType+'.'+name);
4891    }
4892    composeBackboneElement(t, "insurance", name, element, index);
4893    if (element.hasSequenceElement()) {
4894      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
4895    }
4896    if (element.hasFocalElement()) {
4897      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
4898    }
4899    if (element.hasIdentifier()) {
4900      composeIdentifier(t, "InsuranceComponent", "identifier", element.getIdentifier(), -1);
4901    }
4902    if (element.hasCoverage()) {
4903      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
4904    }
4905    if (element.hasBusinessArrangementElement()) {
4906      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
4907    }
4908    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
4909      composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i);
4910    }
4911    if (element.hasClaimResponse()) {
4912      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
4913    }
4914  }
4915
4916  protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) {
4917    if (element == null) 
4918      return;
4919    Complex t;
4920    if (Utilities.noString(parentType))
4921      t = parent;
4922    else {
4923      t = parent.predicate("fhir:"+parentType+'.'+name);
4924    }
4925    composeBackboneElement(t, "accident", name, element, index);
4926    if (element.hasDateElement()) {
4927      composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1);
4928    }
4929    if (element.hasType()) {
4930      composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1);
4931    }
4932    if (element.hasLocation()) {
4933      composeType(t, "AccidentComponent", "location", element.getLocation(), -1);
4934    }
4935  }
4936
4937  protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) {
4938    if (element == null) 
4939      return;
4940    Complex t;
4941    if (Utilities.noString(parentType))
4942      t = parent;
4943    else {
4944      t = parent.predicate("fhir:"+parentType+'.'+name);
4945    }
4946    composeBackboneElement(t, "item", name, element, index);
4947    if (element.hasSequenceElement()) {
4948      composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1);
4949    }
4950    for (int i = 0; i < element.getCareTeamSequence().size(); i++) {
4951      composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i);
4952    }
4953    for (int i = 0; i < element.getDiagnosisSequence().size(); i++) {
4954      composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
4955    }
4956    for (int i = 0; i < element.getProcedureSequence().size(); i++) {
4957      composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i);
4958    }
4959    for (int i = 0; i < element.getInformationSequence().size(); i++) {
4960      composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i);
4961    }
4962    if (element.hasRevenue()) {
4963      composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1);
4964    }
4965    if (element.hasCategory()) {
4966      composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1);
4967    }
4968    if (element.hasProductOrService()) {
4969      composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1);
4970    }
4971    for (int i = 0; i < element.getModifier().size(); i++) {
4972      composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i);
4973    }
4974    for (int i = 0; i < element.getProgramCode().size(); i++) {
4975      composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i);
4976    }
4977    if (element.hasServiced()) {
4978      composeType(t, "ItemComponent", "serviced", element.getServiced(), -1);
4979    }
4980    if (element.hasLocation()) {
4981      composeType(t, "ItemComponent", "location", element.getLocation(), -1);
4982    }
4983    if (element.hasQuantity()) {
4984      composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1);
4985    }
4986    if (element.hasUnitPrice()) {
4987      composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1);
4988    }
4989    if (element.hasFactorElement()) {
4990      composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1);
4991    }
4992    if (element.hasNet()) {
4993      composeMoney(t, "ItemComponent", "net", element.getNet(), -1);
4994    }
4995    for (int i = 0; i < element.getUdi().size(); i++) {
4996      composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i);
4997    }
4998    if (element.hasBodySite()) {
4999      composeCodeableConcept(t, "ItemComponent", "bodySite", element.getBodySite(), -1);
5000    }
5001    for (int i = 0; i < element.getSubSite().size(); i++) {
5002      composeCodeableConcept(t, "ItemComponent", "subSite", element.getSubSite().get(i), i);
5003    }
5004    for (int i = 0; i < element.getEncounter().size(); i++) {
5005      composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i);
5006    }
5007    for (int i = 0; i < element.getDetail().size(); i++) {
5008      composeClaimDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
5009    }
5010  }
5011
5012  protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) {
5013    if (element == null) 
5014      return;
5015    Complex t;
5016    if (Utilities.noString(parentType))
5017      t = parent;
5018    else {
5019      t = parent.predicate("fhir:"+parentType+'.'+name);
5020    }
5021    composeBackboneElement(t, "detail", name, element, index);
5022    if (element.hasSequenceElement()) {
5023      composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1);
5024    }
5025    if (element.hasRevenue()) {
5026      composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1);
5027    }
5028    if (element.hasCategory()) {
5029      composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1);
5030    }
5031    if (element.hasProductOrService()) {
5032      composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1);
5033    }
5034    for (int i = 0; i < element.getModifier().size(); i++) {
5035      composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i);
5036    }
5037    for (int i = 0; i < element.getProgramCode().size(); i++) {
5038      composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i);
5039    }
5040    if (element.hasQuantity()) {
5041      composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1);
5042    }
5043    if (element.hasUnitPrice()) {
5044      composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1);
5045    }
5046    if (element.hasFactorElement()) {
5047      composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1);
5048    }
5049    if (element.hasNet()) {
5050      composeMoney(t, "DetailComponent", "net", element.getNet(), -1);
5051    }
5052    for (int i = 0; i < element.getUdi().size(); i++) {
5053      composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i);
5054    }
5055    for (int i = 0; i < element.getSubDetail().size(); i++) {
5056      composeClaimSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i);
5057    }
5058  }
5059
5060  protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) {
5061    if (element == null) 
5062      return;
5063    Complex t;
5064    if (Utilities.noString(parentType))
5065      t = parent;
5066    else {
5067      t = parent.predicate("fhir:"+parentType+'.'+name);
5068    }
5069    composeBackboneElement(t, "subDetail", name, element, index);
5070    if (element.hasSequenceElement()) {
5071      composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1);
5072    }
5073    if (element.hasRevenue()) {
5074      composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1);
5075    }
5076    if (element.hasCategory()) {
5077      composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1);
5078    }
5079    if (element.hasProductOrService()) {
5080      composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1);
5081    }
5082    for (int i = 0; i < element.getModifier().size(); i++) {
5083      composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i);
5084    }
5085    for (int i = 0; i < element.getProgramCode().size(); i++) {
5086      composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i);
5087    }
5088    if (element.hasQuantity()) {
5089      composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1);
5090    }
5091    if (element.hasUnitPrice()) {
5092      composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
5093    }
5094    if (element.hasFactorElement()) {
5095      composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1);
5096    }
5097    if (element.hasNet()) {
5098      composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1);
5099    }
5100    for (int i = 0; i < element.getUdi().size(); i++) {
5101      composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i);
5102    }
5103  }
5104
5105  protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) {
5106    if (element == null) 
5107      return;
5108    Complex t;
5109    if (Utilities.noString(parentType))
5110      t = parent;
5111    else {
5112      t = parent.predicate("fhir:"+parentType+'.'+name);
5113    }
5114    composeDomainResource(t, "ClaimResponse", name, element, index);
5115    for (int i = 0; i < element.getIdentifier().size(); i++) {
5116      composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i);
5117    }
5118    if (element.hasStatusElement()) {
5119      composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1);
5120    }
5121    if (element.hasType()) {
5122      composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1);
5123    }
5124    if (element.hasSubType()) {
5125      composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1);
5126    }
5127    if (element.hasUseElement()) {
5128      composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1);
5129    }
5130    if (element.hasPatient()) {
5131      composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1);
5132    }
5133    if (element.hasCreatedElement()) {
5134      composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1);
5135    }
5136    if (element.hasInsurer()) {
5137      composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1);
5138    }
5139    if (element.hasRequestor()) {
5140      composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1);
5141    }
5142    if (element.hasRequest()) {
5143      composeReference(t, "ClaimResponse", "request", element.getRequest(), -1);
5144    }
5145    if (element.hasOutcomeElement()) {
5146      composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1);
5147    }
5148    if (element.hasDispositionElement()) {
5149      composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1);
5150    }
5151    if (element.hasPreAuthRefElement()) {
5152      composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
5153    }
5154    if (element.hasPreAuthPeriod()) {
5155      composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1);
5156    }
5157    if (element.hasPayeeType()) {
5158      composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1);
5159    }
5160    for (int i = 0; i < element.getItem().size(); i++) {
5161      composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i);
5162    }
5163    for (int i = 0; i < element.getAddItem().size(); i++) {
5164      composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i);
5165    }
5166    for (int i = 0; i < element.getAdjudication().size(); i++) {
5167      composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i);
5168    }
5169    for (int i = 0; i < element.getTotal().size(); i++) {
5170      composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i);
5171    }
5172    if (element.hasPayment()) {
5173      composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1);
5174    }
5175    if (element.hasFundsReserve()) {
5176      composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1);
5177    }
5178    if (element.hasFormCode()) {
5179      composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1);
5180    }
5181    if (element.hasForm()) {
5182      composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1);
5183    }
5184    for (int i = 0; i < element.getProcessNote().size(); i++) {
5185      composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i);
5186    }
5187    for (int i = 0; i < element.getCommunicationRequest().size(); i++) {
5188      composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i);
5189    }
5190    for (int i = 0; i < element.getInsurance().size(); i++) {
5191      composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i);
5192    }
5193    for (int i = 0; i < element.getError().size(); i++) {
5194      composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i);
5195    }
5196  }
5197
5198  protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) {
5199    if (element == null) 
5200      return;
5201    Complex t;
5202    if (Utilities.noString(parentType))
5203      t = parent;
5204    else {
5205      t = parent.predicate("fhir:"+parentType+'.'+name);
5206    }
5207    composeBackboneElement(t, "item", name, element, index);
5208    if (element.hasItemSequenceElement()) {
5209      composePositiveInt(t, "ItemComponent", "itemSequence", element.getItemSequenceElement(), -1);
5210    }
5211    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5212      composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
5213    }
5214    for (int i = 0; i < element.getAdjudication().size(); i++) {
5215      composeClaimResponseAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i);
5216    }
5217    for (int i = 0; i < element.getDetail().size(); i++) {
5218      composeClaimResponseItemDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
5219    }
5220  }
5221
5222  protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) {
5223    if (element == null) 
5224      return;
5225    Complex t;
5226    if (Utilities.noString(parentType))
5227      t = parent;
5228    else {
5229      t = parent.predicate("fhir:"+parentType+'.'+name);
5230    }
5231    composeBackboneElement(t, "adjudication", name, element, index);
5232    if (element.hasCategory()) {
5233      composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1);
5234    }
5235    if (element.hasReason()) {
5236      composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1);
5237    }
5238    if (element.hasAmount()) {
5239      composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1);
5240    }
5241    if (element.hasValueElement()) {
5242      composeDecimal(t, "AdjudicationComponent", "value", element.getValueElement(), -1);
5243    }
5244  }
5245
5246  protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) {
5247    if (element == null) 
5248      return;
5249    Complex t;
5250    if (Utilities.noString(parentType))
5251      t = parent;
5252    else {
5253      t = parent.predicate("fhir:"+parentType+'.'+name);
5254    }
5255    composeBackboneElement(t, "detail", name, element, index);
5256    if (element.hasDetailSequenceElement()) {
5257      composePositiveInt(t, "ItemDetailComponent", "detailSequence", element.getDetailSequenceElement(), -1);
5258    }
5259    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5260      composePositiveInt(t, "ItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5261    }
5262    for (int i = 0; i < element.getAdjudication().size(); i++) {
5263      composeClaimResponseAdjudicationComponent(t, "ItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5264    }
5265    for (int i = 0; i < element.getSubDetail().size(); i++) {
5266      composeClaimResponseSubDetailComponent(t, "ItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
5267    }
5268  }
5269
5270  protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) {
5271    if (element == null) 
5272      return;
5273    Complex t;
5274    if (Utilities.noString(parentType))
5275      t = parent;
5276    else {
5277      t = parent.predicate("fhir:"+parentType+'.'+name);
5278    }
5279    composeBackboneElement(t, "subDetail", name, element, index);
5280    if (element.hasSubDetailSequenceElement()) {
5281      composePositiveInt(t, "SubDetailComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
5282    }
5283    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5284      composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5285    }
5286    for (int i = 0; i < element.getAdjudication().size(); i++) {
5287      composeClaimResponseAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5288    }
5289  }
5290
5291  protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) {
5292    if (element == null) 
5293      return;
5294    Complex t;
5295    if (Utilities.noString(parentType))
5296      t = parent;
5297    else {
5298      t = parent.predicate("fhir:"+parentType+'.'+name);
5299    }
5300    composeBackboneElement(t, "addItem", name, element, index);
5301    for (int i = 0; i < element.getItemSequence().size(); i++) {
5302      composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i);
5303    }
5304    for (int i = 0; i < element.getDetailSequence().size(); i++) {
5305      composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i);
5306    }
5307    for (int i = 0; i < element.getSubdetailSequence().size(); i++) {
5308      composePositiveInt(t, "AddedItemComponent", "subdetailSequence", element.getSubdetailSequence().get(i), i);
5309    }
5310    for (int i = 0; i < element.getProvider().size(); i++) {
5311      composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i);
5312    }
5313    if (element.hasProductOrService()) {
5314      composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1);
5315    }
5316    for (int i = 0; i < element.getModifier().size(); i++) {
5317      composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i);
5318    }
5319    for (int i = 0; i < element.getProgramCode().size(); i++) {
5320      composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i);
5321    }
5322    if (element.hasServiced()) {
5323      composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1);
5324    }
5325    if (element.hasLocation()) {
5326      composeType(t, "AddedItemComponent", "location", element.getLocation(), -1);
5327    }
5328    if (element.hasQuantity()) {
5329      composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1);
5330    }
5331    if (element.hasUnitPrice()) {
5332      composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1);
5333    }
5334    if (element.hasFactorElement()) {
5335      composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1);
5336    }
5337    if (element.hasNet()) {
5338      composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1);
5339    }
5340    if (element.hasBodySite()) {
5341      composeCodeableConcept(t, "AddedItemComponent", "bodySite", element.getBodySite(), -1);
5342    }
5343    for (int i = 0; i < element.getSubSite().size(); i++) {
5344      composeCodeableConcept(t, "AddedItemComponent", "subSite", element.getSubSite().get(i), i);
5345    }
5346    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5347      composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
5348    }
5349    for (int i = 0; i < element.getAdjudication().size(); i++) {
5350      composeClaimResponseAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i);
5351    }
5352    for (int i = 0; i < element.getDetail().size(); i++) {
5353      composeClaimResponseAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i);
5354    }
5355  }
5356
5357  protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) {
5358    if (element == null) 
5359      return;
5360    Complex t;
5361    if (Utilities.noString(parentType))
5362      t = parent;
5363    else {
5364      t = parent.predicate("fhir:"+parentType+'.'+name);
5365    }
5366    composeBackboneElement(t, "detail", name, element, index);
5367    if (element.hasProductOrService()) {
5368      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1);
5369    }
5370    for (int i = 0; i < element.getModifier().size(); i++) {
5371      composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i);
5372    }
5373    if (element.hasQuantity()) {
5374      composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1);
5375    }
5376    if (element.hasUnitPrice()) {
5377      composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1);
5378    }
5379    if (element.hasFactorElement()) {
5380      composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1);
5381    }
5382    if (element.hasNet()) {
5383      composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1);
5384    }
5385    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5386      composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5387    }
5388    for (int i = 0; i < element.getAdjudication().size(); i++) {
5389      composeClaimResponseAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5390    }
5391    for (int i = 0; i < element.getSubDetail().size(); i++) {
5392      composeClaimResponseAddedItemSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
5393    }
5394  }
5395
5396  protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent element, int index) {
5397    if (element == null) 
5398      return;
5399    Complex t;
5400    if (Utilities.noString(parentType))
5401      t = parent;
5402    else {
5403      t = parent.predicate("fhir:"+parentType+'.'+name);
5404    }
5405    composeBackboneElement(t, "subDetail", name, element, index);
5406    if (element.hasProductOrService()) {
5407      composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrService", element.getProductOrService(), -1);
5408    }
5409    for (int i = 0; i < element.getModifier().size(); i++) {
5410      composeCodeableConcept(t, "AddedItemSubDetailComponent", "modifier", element.getModifier().get(i), i);
5411    }
5412    if (element.hasQuantity()) {
5413      composeQuantity(t, "AddedItemSubDetailComponent", "quantity", element.getQuantity(), -1);
5414    }
5415    if (element.hasUnitPrice()) {
5416      composeMoney(t, "AddedItemSubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
5417    }
5418    if (element.hasFactorElement()) {
5419      composeDecimal(t, "AddedItemSubDetailComponent", "factor", element.getFactorElement(), -1);
5420    }
5421    if (element.hasNet()) {
5422      composeMoney(t, "AddedItemSubDetailComponent", "net", element.getNet(), -1);
5423    }
5424    for (int i = 0; i < element.getNoteNumber().size(); i++) {
5425      composePositiveInt(t, "AddedItemSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
5426    }
5427    for (int i = 0; i < element.getAdjudication().size(); i++) {
5428      composeClaimResponseAdjudicationComponent(t, "AddedItemSubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
5429    }
5430  }
5431
5432  protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent element, int index) {
5433    if (element == null) 
5434      return;
5435    Complex t;
5436    if (Utilities.noString(parentType))
5437      t = parent;
5438    else {
5439      t = parent.predicate("fhir:"+parentType+'.'+name);
5440    }
5441    composeBackboneElement(t, "total", name, element, index);
5442    if (element.hasCategory()) {
5443      composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1);
5444    }
5445    if (element.hasAmount()) {
5446      composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1);
5447    }
5448  }
5449
5450  protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent 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, "payment", name, element, index);
5460    if (element.hasType()) {
5461      composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1);
5462    }
5463    if (element.hasAdjustment()) {
5464      composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1);
5465    }
5466    if (element.hasAdjustmentReason()) {
5467      composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1);
5468    }
5469    if (element.hasDateElement()) {
5470      composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1);
5471    }
5472    if (element.hasAmount()) {
5473      composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1);
5474    }
5475    if (element.hasIdentifier()) {
5476      composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1);
5477    }
5478  }
5479
5480  protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) {
5481    if (element == null) 
5482      return;
5483    Complex t;
5484    if (Utilities.noString(parentType))
5485      t = parent;
5486    else {
5487      t = parent.predicate("fhir:"+parentType+'.'+name);
5488    }
5489    composeBackboneElement(t, "processNote", name, element, index);
5490    if (element.hasNumberElement()) {
5491      composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1);
5492    }
5493    if (element.hasTypeElement()) {
5494      composeEnum(t, "NoteComponent", "type", element.getTypeElement(), -1);
5495    }
5496    if (element.hasTextElement()) {
5497      composeString(t, "NoteComponent", "text", element.getTextElement(), -1);
5498    }
5499    if (element.hasLanguage()) {
5500      composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1);
5501    }
5502  }
5503
5504  protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) {
5505    if (element == null) 
5506      return;
5507    Complex t;
5508    if (Utilities.noString(parentType))
5509      t = parent;
5510    else {
5511      t = parent.predicate("fhir:"+parentType+'.'+name);
5512    }
5513    composeBackboneElement(t, "insurance", name, element, index);
5514    if (element.hasSequenceElement()) {
5515      composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1);
5516    }
5517    if (element.hasFocalElement()) {
5518      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
5519    }
5520    if (element.hasCoverage()) {
5521      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
5522    }
5523    if (element.hasBusinessArrangementElement()) {
5524      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
5525    }
5526    if (element.hasClaimResponse()) {
5527      composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1);
5528    }
5529  }
5530
5531  protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) {
5532    if (element == null) 
5533      return;
5534    Complex t;
5535    if (Utilities.noString(parentType))
5536      t = parent;
5537    else {
5538      t = parent.predicate("fhir:"+parentType+'.'+name);
5539    }
5540    composeBackboneElement(t, "error", name, element, index);
5541    if (element.hasItemSequenceElement()) {
5542      composePositiveInt(t, "ErrorComponent", "itemSequence", element.getItemSequenceElement(), -1);
5543    }
5544    if (element.hasDetailSequenceElement()) {
5545      composePositiveInt(t, "ErrorComponent", "detailSequence", element.getDetailSequenceElement(), -1);
5546    }
5547    if (element.hasSubDetailSequenceElement()) {
5548      composePositiveInt(t, "ErrorComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1);
5549    }
5550    if (element.hasCode()) {
5551      composeCodeableConcept(t, "ErrorComponent", "code", element.getCode(), -1);
5552    }
5553  }
5554
5555  protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) {
5556    if (element == null) 
5557      return;
5558    Complex t;
5559    if (Utilities.noString(parentType))
5560      t = parent;
5561    else {
5562      t = parent.predicate("fhir:"+parentType+'.'+name);
5563    }
5564    composeDomainResource(t, "ClinicalImpression", name, element, index);
5565    for (int i = 0; i < element.getIdentifier().size(); i++) {
5566      composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i);
5567    }
5568    if (element.hasStatusElement()) {
5569      composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1);
5570    }
5571    if (element.hasStatusReason()) {
5572      composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1);
5573    }
5574    if (element.hasDescriptionElement()) {
5575      composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1);
5576    }
5577    if (element.hasSubject()) {
5578      composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1);
5579    }
5580    if (element.hasEncounter()) {
5581      composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1);
5582    }
5583    if (element.hasEffective()) {
5584      composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1);
5585    }
5586    if (element.hasDateElement()) {
5587      composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1);
5588    }
5589    if (element.hasPerformer()) {
5590      composeReference(t, "ClinicalImpression", "performer", element.getPerformer(), -1);
5591    }
5592    if (element.hasPrevious()) {
5593      composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1);
5594    }
5595    for (int i = 0; i < element.getProblem().size(); i++) {
5596      composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i);
5597    }
5598    for (int i = 0; i < element.getProtocol().size(); i++) {
5599      composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i);
5600    }
5601    if (element.hasSummaryElement()) {
5602      composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1);
5603    }
5604    for (int i = 0; i < element.getFinding().size(); i++) {
5605      composeClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i);
5606    }
5607    for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) {
5608      composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i);
5609    }
5610    for (int i = 0; i < element.getPrognosisReference().size(); i++) {
5611      composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i);
5612    }
5613    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
5614      composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i);
5615    }
5616    for (int i = 0; i < element.getNote().size(); i++) {
5617      composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i);
5618    }
5619  }
5620
5621  protected void composeClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) {
5622    if (element == null) 
5623      return;
5624    Complex t;
5625    if (Utilities.noString(parentType))
5626      t = parent;
5627    else {
5628      t = parent.predicate("fhir:"+parentType+'.'+name);
5629    }
5630    composeBackboneElement(t, "finding", name, element, index);
5631    if (element.hasItem()) {
5632      composeCodeableReference(t, "ClinicalImpressionFindingComponent", "item", element.getItem(), -1);
5633    }
5634    if (element.hasBasisElement()) {
5635      composeString(t, "ClinicalImpressionFindingComponent", "basis", element.getBasisElement(), -1);
5636    }
5637  }
5638
5639  protected void composeClinicalUseIssue(Complex parent, String parentType, String name, ClinicalUseIssue element, int index) {
5640    if (element == null) 
5641      return;
5642    Complex t;
5643    if (Utilities.noString(parentType))
5644      t = parent;
5645    else {
5646      t = parent.predicate("fhir:"+parentType+'.'+name);
5647    }
5648    composeDomainResource(t, "ClinicalUseIssue", name, element, index);
5649    for (int i = 0; i < element.getIdentifier().size(); i++) {
5650      composeIdentifier(t, "ClinicalUseIssue", "identifier", element.getIdentifier().get(i), i);
5651    }
5652    if (element.hasTypeElement()) {
5653      composeEnum(t, "ClinicalUseIssue", "type", element.getTypeElement(), -1);
5654    }
5655    for (int i = 0; i < element.getSubject().size(); i++) {
5656      composeReference(t, "ClinicalUseIssue", "subject", element.getSubject().get(i), i);
5657    }
5658    if (element.hasStatus()) {
5659      composeCodeableConcept(t, "ClinicalUseIssue", "status", element.getStatus(), -1);
5660    }
5661    if (element.hasDescriptionElement()) {
5662      composeMarkdown(t, "ClinicalUseIssue", "description", element.getDescriptionElement(), -1);
5663    }
5664    if (element.hasContraindication()) {
5665      composeClinicalUseIssueContraindicationComponent(t, "ClinicalUseIssue", "contraindication", element.getContraindication(), -1);
5666    }
5667    if (element.hasIndication()) {
5668      composeClinicalUseIssueIndicationComponent(t, "ClinicalUseIssue", "indication", element.getIndication(), -1);
5669    }
5670    if (element.hasInteraction()) {
5671      composeClinicalUseIssueInteractionComponent(t, "ClinicalUseIssue", "interaction", element.getInteraction(), -1);
5672    }
5673    for (int i = 0; i < element.getPopulation().size(); i++) {
5674      composePopulation(t, "ClinicalUseIssue", "population", element.getPopulation().get(i), i);
5675    }
5676    if (element.hasUndesirableEffect()) {
5677      composeClinicalUseIssueUndesirableEffectComponent(t, "ClinicalUseIssue", "undesirableEffect", element.getUndesirableEffect(), -1);
5678    }
5679  }
5680
5681  protected void composeClinicalUseIssueContraindicationComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueContraindicationComponent element, int index) {
5682    if (element == null) 
5683      return;
5684    Complex t;
5685    if (Utilities.noString(parentType))
5686      t = parent;
5687    else {
5688      t = parent.predicate("fhir:"+parentType+'.'+name);
5689    }
5690    composeBackboneElement(t, "contraindication", name, element, index);
5691    if (element.hasDiseaseSymptomProcedure()) {
5692      composeCodeableConcept(t, "ClinicalUseIssueContraindicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
5693    }
5694    if (element.hasDiseaseStatus()) {
5695      composeCodeableConcept(t, "ClinicalUseIssueContraindicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
5696    }
5697    for (int i = 0; i < element.getComorbidity().size(); i++) {
5698      composeCodeableConcept(t, "ClinicalUseIssueContraindicationComponent", "comorbidity", element.getComorbidity().get(i), i);
5699    }
5700    for (int i = 0; i < element.getIndication().size(); i++) {
5701      composeReference(t, "ClinicalUseIssueContraindicationComponent", "indication", element.getIndication().get(i), i);
5702    }
5703    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
5704      composeClinicalUseIssueContraindicationOtherTherapyComponent(t, "ClinicalUseIssueContraindicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
5705    }
5706  }
5707
5708  protected void composeClinicalUseIssueContraindicationOtherTherapyComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueContraindicationOtherTherapyComponent element, int index) {
5709    if (element == null) 
5710      return;
5711    Complex t;
5712    if (Utilities.noString(parentType))
5713      t = parent;
5714    else {
5715      t = parent.predicate("fhir:"+parentType+'.'+name);
5716    }
5717    composeBackboneElement(t, "otherTherapy", name, element, index);
5718    if (element.hasTherapyRelationshipType()) {
5719      composeCodeableConcept(t, "ClinicalUseIssueContraindicationOtherTherapyComponent", "therapyRelationshipType", element.getTherapyRelationshipType(), -1);
5720    }
5721    if (element.hasMedication()) {
5722      composeType(t, "ClinicalUseIssueContraindicationOtherTherapyComponent", "medication", element.getMedication(), -1);
5723    }
5724  }
5725
5726  protected void composeClinicalUseIssueIndicationComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueIndicationComponent element, int index) {
5727    if (element == null) 
5728      return;
5729    Complex t;
5730    if (Utilities.noString(parentType))
5731      t = parent;
5732    else {
5733      t = parent.predicate("fhir:"+parentType+'.'+name);
5734    }
5735    composeBackboneElement(t, "indication", name, element, index);
5736    if (element.hasDiseaseSymptomProcedure()) {
5737      composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1);
5738    }
5739    if (element.hasDiseaseStatus()) {
5740      composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1);
5741    }
5742    for (int i = 0; i < element.getComorbidity().size(); i++) {
5743      composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "comorbidity", element.getComorbidity().get(i), i);
5744    }
5745    if (element.hasIntendedEffect()) {
5746      composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "intendedEffect", element.getIntendedEffect(), -1);
5747    }
5748    if (element.hasDuration()) {
5749      composeQuantity(t, "ClinicalUseIssueIndicationComponent", "duration", element.getDuration(), -1);
5750    }
5751    for (int i = 0; i < element.getUndesirableEffect().size(); i++) {
5752      composeReference(t, "ClinicalUseIssueIndicationComponent", "undesirableEffect", element.getUndesirableEffect().get(i), i);
5753    }
5754    for (int i = 0; i < element.getOtherTherapy().size(); i++) {
5755      composeClinicalUseIssueContraindicationOtherTherapyComponent(t, "ClinicalUseIssueIndicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i);
5756    }
5757  }
5758
5759  protected void composeClinicalUseIssueInteractionComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueInteractionComponent element, int index) {
5760    if (element == null) 
5761      return;
5762    Complex t;
5763    if (Utilities.noString(parentType))
5764      t = parent;
5765    else {
5766      t = parent.predicate("fhir:"+parentType+'.'+name);
5767    }
5768    composeBackboneElement(t, "interaction", name, element, index);
5769    for (int i = 0; i < element.getInteractant().size(); i++) {
5770      composeClinicalUseIssueInteractionInteractantComponent(t, "ClinicalUseIssueInteractionComponent", "interactant", element.getInteractant().get(i), i);
5771    }
5772    if (element.hasType()) {
5773      composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "type", element.getType(), -1);
5774    }
5775    if (element.hasEffect()) {
5776      composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "effect", element.getEffect(), -1);
5777    }
5778    if (element.hasIncidence()) {
5779      composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "incidence", element.getIncidence(), -1);
5780    }
5781    if (element.hasManagement()) {
5782      composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "management", element.getManagement(), -1);
5783    }
5784  }
5785
5786  protected void composeClinicalUseIssueInteractionInteractantComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueInteractionInteractantComponent element, int index) {
5787    if (element == null) 
5788      return;
5789    Complex t;
5790    if (Utilities.noString(parentType))
5791      t = parent;
5792    else {
5793      t = parent.predicate("fhir:"+parentType+'.'+name);
5794    }
5795    composeBackboneElement(t, "interactant", name, element, index);
5796    if (element.hasItem()) {
5797      composeType(t, "ClinicalUseIssueInteractionInteractantComponent", "item", element.getItem(), -1);
5798    }
5799  }
5800
5801  protected void composeClinicalUseIssueUndesirableEffectComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueUndesirableEffectComponent element, int index) {
5802    if (element == null) 
5803      return;
5804    Complex t;
5805    if (Utilities.noString(parentType))
5806      t = parent;
5807    else {
5808      t = parent.predicate("fhir:"+parentType+'.'+name);
5809    }
5810    composeBackboneElement(t, "undesirableEffect", name, element, index);
5811    if (element.hasSymptomConditionEffect()) {
5812      composeCodeableConcept(t, "ClinicalUseIssueUndesirableEffectComponent", "symptomConditionEffect", element.getSymptomConditionEffect(), -1);
5813    }
5814    if (element.hasClassification()) {
5815      composeCodeableConcept(t, "ClinicalUseIssueUndesirableEffectComponent", "classification", element.getClassification(), -1);
5816    }
5817    if (element.hasFrequencyOfOccurrence()) {
5818      composeCodeableConcept(t, "ClinicalUseIssueUndesirableEffectComponent", "frequencyOfOccurrence", element.getFrequencyOfOccurrence(), -1);
5819    }
5820  }
5821
5822  protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) {
5823    if (element == null) 
5824      return;
5825    Complex t;
5826    if (Utilities.noString(parentType))
5827      t = parent;
5828    else {
5829      t = parent.predicate("fhir:"+parentType+'.'+name);
5830    }
5831    composeCanonicalResource(t, "CodeSystem", name, element, index);
5832    if (element.hasUrlElement()) {
5833      composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1);
5834    }
5835    for (int i = 0; i < element.getIdentifier().size(); i++) {
5836      composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i);
5837    }
5838    if (element.hasVersionElement()) {
5839      composeString(t, "CodeSystem", "version", element.getVersionElement(), -1);
5840    }
5841    if (element.hasNameElement()) {
5842      composeString(t, "CodeSystem", "name", element.getNameElement(), -1);
5843    }
5844    if (element.hasTitleElement()) {
5845      composeString(t, "CodeSystem", "title", element.getTitleElement(), -1);
5846    }
5847    if (element.hasStatusElement()) {
5848      composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1);
5849    }
5850    if (element.hasExperimentalElement()) {
5851      composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1);
5852    }
5853    if (element.hasDateElement()) {
5854      composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1);
5855    }
5856    if (element.hasPublisherElement()) {
5857      composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1);
5858    }
5859    for (int i = 0; i < element.getContact().size(); i++) {
5860      composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i);
5861    }
5862    if (element.hasDescriptionElement()) {
5863      composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1);
5864    }
5865    for (int i = 0; i < element.getUseContext().size(); i++) {
5866      composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i);
5867    }
5868    for (int i = 0; i < element.getJurisdiction().size(); i++) {
5869      composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i);
5870    }
5871    if (element.hasPurposeElement()) {
5872      composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1);
5873    }
5874    if (element.hasCopyrightElement()) {
5875      composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1);
5876    }
5877    if (element.hasCaseSensitiveElement()) {
5878      composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1);
5879    }
5880    if (element.hasValueSetElement()) {
5881      composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1);
5882    }
5883    if (element.hasHierarchyMeaningElement()) {
5884      composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1);
5885    }
5886    if (element.hasCompositionalElement()) {
5887      composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1);
5888    }
5889    if (element.hasVersionNeededElement()) {
5890      composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1);
5891    }
5892    if (element.hasContentElement()) {
5893      composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1);
5894    }
5895    if (element.hasSupplementsElement()) {
5896      composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1);
5897    }
5898    if (element.hasCountElement()) {
5899      composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1);
5900    }
5901    for (int i = 0; i < element.getFilter().size(); i++) {
5902      composeCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i);
5903    }
5904    for (int i = 0; i < element.getProperty().size(); i++) {
5905      composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i);
5906    }
5907    for (int i = 0; i < element.getConcept().size(); i++) {
5908      composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i);
5909    }
5910  }
5911
5912  protected void composeCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) {
5913    if (element == null) 
5914      return;
5915    Complex t;
5916    if (Utilities.noString(parentType))
5917      t = parent;
5918    else {
5919      t = parent.predicate("fhir:"+parentType+'.'+name);
5920    }
5921    composeBackboneElement(t, "filter", name, element, index);
5922    if (element.hasCodeElement()) {
5923      composeCode(t, "CodeSystemFilterComponent", "code", element.getCodeElement(), -1);
5924    }
5925    if (element.hasDescriptionElement()) {
5926      composeString(t, "CodeSystemFilterComponent", "description", element.getDescriptionElement(), -1);
5927    }
5928    for (int i = 0; i < element.getOperator().size(); i++) {
5929      composeEnum(t, "CodeSystemFilterComponent", "operator", element.getOperator().get(i), i);
5930    }
5931    if (element.hasValueElement()) {
5932      composeString(t, "CodeSystemFilterComponent", "value", element.getValueElement(), -1);
5933    }
5934  }
5935
5936  protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) {
5937    if (element == null) 
5938      return;
5939    Complex t;
5940    if (Utilities.noString(parentType))
5941      t = parent;
5942    else {
5943      t = parent.predicate("fhir:"+parentType+'.'+name);
5944    }
5945    composeBackboneElement(t, "property", name, element, index);
5946    if (element.hasCodeElement()) {
5947      composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1);
5948    }
5949    if (element.hasUriElement()) {
5950      composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1);
5951    }
5952    if (element.hasDescriptionElement()) {
5953      composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1);
5954    }
5955    if (element.hasTypeElement()) {
5956      composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1);
5957    }
5958  }
5959
5960  protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) {
5961    if (element == null) 
5962      return;
5963    Complex t;
5964    if (Utilities.noString(parentType))
5965      t = parent;
5966    else {
5967      t = parent.predicate("fhir:"+parentType+'.'+name);
5968    }
5969    composeBackboneElement(t, "concept", name, element, index);
5970    if (element.hasCodeElement()) {
5971      composeCode(t, "ConceptDefinitionComponent", "code", element.getCodeElement(), -1);
5972    }
5973    if (element.hasDisplayElement()) {
5974      composeString(t, "ConceptDefinitionComponent", "display", element.getDisplayElement(), -1);
5975    }
5976    if (element.hasDefinitionElement()) {
5977      composeString(t, "ConceptDefinitionComponent", "definition", element.getDefinitionElement(), -1);
5978    }
5979    for (int i = 0; i < element.getDesignation().size(); i++) {
5980      composeCodeSystemConceptDefinitionDesignationComponent(t, "ConceptDefinitionComponent", "designation", element.getDesignation().get(i), i);
5981    }
5982    for (int i = 0; i < element.getProperty().size(); i++) {
5983      composeCodeSystemConceptPropertyComponent(t, "ConceptDefinitionComponent", "property", element.getProperty().get(i), i);
5984    }
5985    for (int i = 0; i < element.getConcept().size(); i++) {
5986      composeCodeSystemConceptDefinitionComponent(t, "ConceptDefinitionComponent", "concept", element.getConcept().get(i), i);
5987    }
5988  }
5989
5990  protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) {
5991    if (element == null) 
5992      return;
5993    Complex t;
5994    if (Utilities.noString(parentType))
5995      t = parent;
5996    else {
5997      t = parent.predicate("fhir:"+parentType+'.'+name);
5998    }
5999    composeBackboneElement(t, "designation", name, element, index);
6000    if (element.hasLanguageElement()) {
6001      composeCode(t, "ConceptDefinitionDesignationComponent", "language", element.getLanguageElement(), -1);
6002    }
6003    if (element.hasUse()) {
6004      composeCoding(t, "ConceptDefinitionDesignationComponent", "use", element.getUse(), -1);
6005    }
6006    if (element.hasValueElement()) {
6007      composeString(t, "ConceptDefinitionDesignationComponent", "value", element.getValueElement(), -1);
6008    }
6009  }
6010
6011  protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) {
6012    if (element == null) 
6013      return;
6014    Complex t;
6015    if (Utilities.noString(parentType))
6016      t = parent;
6017    else {
6018      t = parent.predicate("fhir:"+parentType+'.'+name);
6019    }
6020    composeBackboneElement(t, "property", name, element, index);
6021    if (element.hasCodeElement()) {
6022      composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1);
6023    }
6024    if (element.hasValue()) {
6025      composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1);
6026    }
6027  }
6028
6029  protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) {
6030    if (element == null) 
6031      return;
6032    Complex t;
6033    if (Utilities.noString(parentType))
6034      t = parent;
6035    else {
6036      t = parent.predicate("fhir:"+parentType+'.'+name);
6037    }
6038    composeDomainResource(t, "Communication", name, element, index);
6039    for (int i = 0; i < element.getIdentifier().size(); i++) {
6040      composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i);
6041    }
6042    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
6043      composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
6044    }
6045    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
6046      composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i);
6047    }
6048    for (int i = 0; i < element.getBasedOn().size(); i++) {
6049      composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i);
6050    }
6051    for (int i = 0; i < element.getPartOf().size(); i++) {
6052      composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i);
6053    }
6054    for (int i = 0; i < element.getInResponseTo().size(); i++) {
6055      composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i);
6056    }
6057    if (element.hasStatusElement()) {
6058      composeEnum(t, "Communication", "status", element.getStatusElement(), -1);
6059    }
6060    if (element.hasStatusReason()) {
6061      composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1);
6062    }
6063    for (int i = 0; i < element.getCategory().size(); i++) {
6064      composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i);
6065    }
6066    if (element.hasPriorityElement()) {
6067      composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1);
6068    }
6069    for (int i = 0; i < element.getMedium().size(); i++) {
6070      composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i);
6071    }
6072    if (element.hasSubject()) {
6073      composeReference(t, "Communication", "subject", element.getSubject(), -1);
6074    }
6075    if (element.hasTopic()) {
6076      composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1);
6077    }
6078    for (int i = 0; i < element.getAbout().size(); i++) {
6079      composeReference(t, "Communication", "about", element.getAbout().get(i), i);
6080    }
6081    if (element.hasEncounter()) {
6082      composeReference(t, "Communication", "encounter", element.getEncounter(), -1);
6083    }
6084    if (element.hasSentElement()) {
6085      composeDateTime(t, "Communication", "sent", element.getSentElement(), -1);
6086    }
6087    if (element.hasReceivedElement()) {
6088      composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1);
6089    }
6090    for (int i = 0; i < element.getRecipient().size(); i++) {
6091      composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i);
6092    }
6093    if (element.hasSender()) {
6094      composeReference(t, "Communication", "sender", element.getSender(), -1);
6095    }
6096    for (int i = 0; i < element.getReason().size(); i++) {
6097      composeCodeableReference(t, "Communication", "reason", element.getReason().get(i), i);
6098    }
6099    for (int i = 0; i < element.getPayload().size(); i++) {
6100      composeCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i);
6101    }
6102    for (int i = 0; i < element.getNote().size(); i++) {
6103      composeAnnotation(t, "Communication", "note", element.getNote().get(i), i);
6104    }
6105  }
6106
6107  protected void composeCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) {
6108    if (element == null) 
6109      return;
6110    Complex t;
6111    if (Utilities.noString(parentType))
6112      t = parent;
6113    else {
6114      t = parent.predicate("fhir:"+parentType+'.'+name);
6115    }
6116    composeBackboneElement(t, "payload", name, element, index);
6117    if (element.hasContent()) {
6118      composeType(t, "CommunicationPayloadComponent", "content", element.getContent(), -1);
6119    }
6120  }
6121
6122  protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) {
6123    if (element == null) 
6124      return;
6125    Complex t;
6126    if (Utilities.noString(parentType))
6127      t = parent;
6128    else {
6129      t = parent.predicate("fhir:"+parentType+'.'+name);
6130    }
6131    composeDomainResource(t, "CommunicationRequest", name, element, index);
6132    for (int i = 0; i < element.getIdentifier().size(); i++) {
6133      composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i);
6134    }
6135    for (int i = 0; i < element.getBasedOn().size(); i++) {
6136      composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i);
6137    }
6138    for (int i = 0; i < element.getReplaces().size(); i++) {
6139      composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i);
6140    }
6141    if (element.hasGroupIdentifier()) {
6142      composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
6143    }
6144    if (element.hasStatusElement()) {
6145      composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1);
6146    }
6147    if (element.hasStatusReason()) {
6148      composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1);
6149    }
6150    for (int i = 0; i < element.getCategory().size(); i++) {
6151      composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i);
6152    }
6153    if (element.hasPriorityElement()) {
6154      composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1);
6155    }
6156    if (element.hasDoNotPerformElement()) {
6157      composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
6158    }
6159    for (int i = 0; i < element.getMedium().size(); i++) {
6160      composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i);
6161    }
6162    if (element.hasSubject()) {
6163      composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1);
6164    }
6165    for (int i = 0; i < element.getAbout().size(); i++) {
6166      composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i);
6167    }
6168    if (element.hasEncounter()) {
6169      composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1);
6170    }
6171    for (int i = 0; i < element.getPayload().size(); i++) {
6172      composeCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i);
6173    }
6174    if (element.hasOccurrence()) {
6175      composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1);
6176    }
6177    if (element.hasAuthoredOnElement()) {
6178      composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
6179    }
6180    if (element.hasRequester()) {
6181      composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1);
6182    }
6183    for (int i = 0; i < element.getRecipient().size(); i++) {
6184      composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i);
6185    }
6186    for (int i = 0; i < element.getInformationProvider().size(); i++) {
6187      composeReference(t, "CommunicationRequest", "informationProvider", element.getInformationProvider().get(i), i);
6188    }
6189    for (int i = 0; i < element.getReason().size(); i++) {
6190      composeCodeableReference(t, "CommunicationRequest", "reason", element.getReason().get(i), i);
6191    }
6192    for (int i = 0; i < element.getNote().size(); i++) {
6193      composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i);
6194    }
6195  }
6196
6197  protected void composeCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) {
6198    if (element == null) 
6199      return;
6200    Complex t;
6201    if (Utilities.noString(parentType))
6202      t = parent;
6203    else {
6204      t = parent.predicate("fhir:"+parentType+'.'+name);
6205    }
6206    composeBackboneElement(t, "payload", name, element, index);
6207    if (element.hasContent()) {
6208      composeType(t, "CommunicationRequestPayloadComponent", "content", element.getContent(), -1);
6209    }
6210  }
6211
6212  protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) {
6213    if (element == null) 
6214      return;
6215    Complex t;
6216    if (Utilities.noString(parentType))
6217      t = parent;
6218    else {
6219      t = parent.predicate("fhir:"+parentType+'.'+name);
6220    }
6221    composeCanonicalResource(t, "CompartmentDefinition", name, element, index);
6222    if (element.hasUrlElement()) {
6223      composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1);
6224    }
6225    if (element.hasVersionElement()) {
6226      composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1);
6227    }
6228    if (element.hasNameElement()) {
6229      composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1);
6230    }
6231    if (element.hasStatusElement()) {
6232      composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1);
6233    }
6234    if (element.hasExperimentalElement()) {
6235      composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1);
6236    }
6237    if (element.hasDateElement()) {
6238      composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1);
6239    }
6240    if (element.hasPublisherElement()) {
6241      composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1);
6242    }
6243    for (int i = 0; i < element.getContact().size(); i++) {
6244      composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i);
6245    }
6246    if (element.hasDescriptionElement()) {
6247      composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1);
6248    }
6249    for (int i = 0; i < element.getUseContext().size(); i++) {
6250      composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i);
6251    }
6252    if (element.hasPurposeElement()) {
6253      composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1);
6254    }
6255    if (element.hasCodeElement()) {
6256      composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1);
6257    }
6258    if (element.hasSearchElement()) {
6259      composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1);
6260    }
6261    for (int i = 0; i < element.getResource().size(); i++) {
6262      composeCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i);
6263    }
6264  }
6265
6266  protected void composeCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) {
6267    if (element == null) 
6268      return;
6269    Complex t;
6270    if (Utilities.noString(parentType))
6271      t = parent;
6272    else {
6273      t = parent.predicate("fhir:"+parentType+'.'+name);
6274    }
6275    composeBackboneElement(t, "resource", name, element, index);
6276    if (element.hasCodeElement()) {
6277      composeCode(t, "CompartmentDefinitionResourceComponent", "code", element.getCodeElement(), -1);
6278    }
6279    for (int i = 0; i < element.getParam().size(); i++) {
6280      composeString(t, "CompartmentDefinitionResourceComponent", "param", element.getParam().get(i), i);
6281    }
6282    if (element.hasDocumentationElement()) {
6283      composeString(t, "CompartmentDefinitionResourceComponent", "documentation", element.getDocumentationElement(), -1);
6284    }
6285  }
6286
6287  protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) {
6288    if (element == null) 
6289      return;
6290    Complex t;
6291    if (Utilities.noString(parentType))
6292      t = parent;
6293    else {
6294      t = parent.predicate("fhir:"+parentType+'.'+name);
6295    }
6296    composeDomainResource(t, "Composition", name, element, index);
6297    if (element.hasIdentifier()) {
6298      composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1);
6299    }
6300    if (element.hasStatusElement()) {
6301      composeEnum(t, "Composition", "status", element.getStatusElement(), -1);
6302    }
6303    if (element.hasType()) {
6304      composeCodeableConcept(t, "Composition", "type", element.getType(), -1);
6305    }
6306    for (int i = 0; i < element.getCategory().size(); i++) {
6307      composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i);
6308    }
6309    if (element.hasSubject()) {
6310      composeReference(t, "Composition", "subject", element.getSubject(), -1);
6311    }
6312    if (element.hasEncounter()) {
6313      composeReference(t, "Composition", "encounter", element.getEncounter(), -1);
6314    }
6315    if (element.hasDateElement()) {
6316      composeDateTime(t, "Composition", "date", element.getDateElement(), -1);
6317    }
6318    for (int i = 0; i < element.getAuthor().size(); i++) {
6319      composeReference(t, "Composition", "author", element.getAuthor().get(i), i);
6320    }
6321    if (element.hasTitleElement()) {
6322      composeString(t, "Composition", "title", element.getTitleElement(), -1);
6323    }
6324    if (element.hasConfidentialityElement()) {
6325      composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1);
6326    }
6327    for (int i = 0; i < element.getAttester().size(); i++) {
6328      composeCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i);
6329    }
6330    if (element.hasCustodian()) {
6331      composeReference(t, "Composition", "custodian", element.getCustodian(), -1);
6332    }
6333    for (int i = 0; i < element.getRelatesTo().size(); i++) {
6334      composeCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i);
6335    }
6336    for (int i = 0; i < element.getEvent().size(); i++) {
6337      composeCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i);
6338    }
6339    for (int i = 0; i < element.getSection().size(); i++) {
6340      composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i);
6341    }
6342  }
6343
6344  protected void composeCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) {
6345    if (element == null) 
6346      return;
6347    Complex t;
6348    if (Utilities.noString(parentType))
6349      t = parent;
6350    else {
6351      t = parent.predicate("fhir:"+parentType+'.'+name);
6352    }
6353    composeBackboneElement(t, "attester", name, element, index);
6354    if (element.hasModeElement()) {
6355      composeEnum(t, "CompositionAttesterComponent", "mode", element.getModeElement(), -1);
6356    }
6357    if (element.hasTimeElement()) {
6358      composeDateTime(t, "CompositionAttesterComponent", "time", element.getTimeElement(), -1);
6359    }
6360    if (element.hasParty()) {
6361      composeReference(t, "CompositionAttesterComponent", "party", element.getParty(), -1);
6362    }
6363  }
6364
6365  protected void composeCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) {
6366    if (element == null) 
6367      return;
6368    Complex t;
6369    if (Utilities.noString(parentType))
6370      t = parent;
6371    else {
6372      t = parent.predicate("fhir:"+parentType+'.'+name);
6373    }
6374    composeBackboneElement(t, "relatesTo", name, element, index);
6375    if (element.hasCodeElement()) {
6376      composeEnum(t, "CompositionRelatesToComponent", "code", element.getCodeElement(), -1);
6377    }
6378    if (element.hasTarget()) {
6379      composeType(t, "CompositionRelatesToComponent", "target", element.getTarget(), -1);
6380    }
6381  }
6382
6383  protected void composeCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) {
6384    if (element == null) 
6385      return;
6386    Complex t;
6387    if (Utilities.noString(parentType))
6388      t = parent;
6389    else {
6390      t = parent.predicate("fhir:"+parentType+'.'+name);
6391    }
6392    composeBackboneElement(t, "event", name, element, index);
6393    for (int i = 0; i < element.getCode().size(); i++) {
6394      composeCodeableConcept(t, "CompositionEventComponent", "code", element.getCode().get(i), i);
6395    }
6396    if (element.hasPeriod()) {
6397      composePeriod(t, "CompositionEventComponent", "period", element.getPeriod(), -1);
6398    }
6399    for (int i = 0; i < element.getDetail().size(); i++) {
6400      composeReference(t, "CompositionEventComponent", "detail", element.getDetail().get(i), i);
6401    }
6402  }
6403
6404  protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) {
6405    if (element == null) 
6406      return;
6407    Complex t;
6408    if (Utilities.noString(parentType))
6409      t = parent;
6410    else {
6411      t = parent.predicate("fhir:"+parentType+'.'+name);
6412    }
6413    composeBackboneElement(t, "section", name, element, index);
6414    if (element.hasTitleElement()) {
6415      composeString(t, "SectionComponent", "title", element.getTitleElement(), -1);
6416    }
6417    if (element.hasCode()) {
6418      composeCodeableConcept(t, "SectionComponent", "code", element.getCode(), -1);
6419    }
6420    for (int i = 0; i < element.getAuthor().size(); i++) {
6421      composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i);
6422    }
6423    if (element.hasFocus()) {
6424      composeReference(t, "SectionComponent", "focus", element.getFocus(), -1);
6425    }
6426    if (element.hasText()) {
6427      composeNarrative(t, "SectionComponent", "text", element.getText(), -1);
6428    }
6429    if (element.hasModeElement()) {
6430      composeEnum(t, "SectionComponent", "mode", element.getModeElement(), -1);
6431    }
6432    if (element.hasOrderedBy()) {
6433      composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1);
6434    }
6435    for (int i = 0; i < element.getEntry().size(); i++) {
6436      composeReference(t, "SectionComponent", "entry", element.getEntry().get(i), i);
6437    }
6438    if (element.hasEmptyReason()) {
6439      composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1);
6440    }
6441    for (int i = 0; i < element.getSection().size(); i++) {
6442      composeCompositionSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i);
6443    }
6444  }
6445
6446  protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) {
6447    if (element == null) 
6448      return;
6449    Complex t;
6450    if (Utilities.noString(parentType))
6451      t = parent;
6452    else {
6453      t = parent.predicate("fhir:"+parentType+'.'+name);
6454    }
6455    composeCanonicalResource(t, "ConceptMap", name, element, index);
6456    if (element.hasUrlElement()) {
6457      composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1);
6458    }
6459    if (element.hasIdentifier()) {
6460      composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifierFirstRep(), -1);
6461    }
6462    if (element.hasVersionElement()) {
6463      composeString(t, "ConceptMap", "version", element.getVersionElement(), -1);
6464    }
6465    if (element.hasNameElement()) {
6466      composeString(t, "ConceptMap", "name", element.getNameElement(), -1);
6467    }
6468    if (element.hasTitleElement()) {
6469      composeString(t, "ConceptMap", "title", element.getTitleElement(), -1);
6470    }
6471    if (element.hasStatusElement()) {
6472      composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1);
6473    }
6474    if (element.hasExperimentalElement()) {
6475      composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1);
6476    }
6477    if (element.hasDateElement()) {
6478      composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1);
6479    }
6480    if (element.hasPublisherElement()) {
6481      composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1);
6482    }
6483    for (int i = 0; i < element.getContact().size(); i++) {
6484      composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i);
6485    }
6486    if (element.hasDescriptionElement()) {
6487      composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1);
6488    }
6489    for (int i = 0; i < element.getUseContext().size(); i++) {
6490      composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i);
6491    }
6492    for (int i = 0; i < element.getJurisdiction().size(); i++) {
6493      composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i);
6494    }
6495    if (element.hasPurposeElement()) {
6496      composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1);
6497    }
6498    if (element.hasCopyrightElement()) {
6499      composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1);
6500    }
6501    if (element.hasSource()) {
6502      composeType(t, "ConceptMap", "source", element.getSource(), -1);
6503    }
6504    if (element.hasTarget()) {
6505      composeType(t, "ConceptMap", "target", element.getTarget(), -1);
6506    }
6507    for (int i = 0; i < element.getGroup().size(); i++) {
6508      composeConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i);
6509    }
6510  }
6511
6512  protected void composeConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) {
6513    if (element == null) 
6514      return;
6515    Complex t;
6516    if (Utilities.noString(parentType))
6517      t = parent;
6518    else {
6519      t = parent.predicate("fhir:"+parentType+'.'+name);
6520    }
6521    composeBackboneElement(t, "group", name, element, index);
6522    if (element.hasSourceElement()) {
6523      composeUri(t, "ConceptMapGroupComponent", "source", element.getSourceElement(), -1);
6524    }
6525    if (element.hasSourceVersionElement()) {
6526      composeString(t, "ConceptMapGroupComponent", "sourceVersion", element.getSourceVersionElement(), -1);
6527    }
6528    if (element.hasTargetElement()) {
6529      composeUri(t, "ConceptMapGroupComponent", "target", element.getTargetElement(), -1);
6530    }
6531    if (element.hasTargetVersionElement()) {
6532      composeString(t, "ConceptMapGroupComponent", "targetVersion", element.getTargetVersionElement(), -1);
6533    }
6534    for (int i = 0; i < element.getElement().size(); i++) {
6535      composeConceptMapSourceElementComponent(t, "ConceptMapGroupComponent", "element", element.getElement().get(i), i);
6536    }
6537    if (element.hasUnmapped()) {
6538      composeConceptMapGroupUnmappedComponent(t, "ConceptMapGroupComponent", "unmapped", element.getUnmapped(), -1);
6539    }
6540  }
6541
6542  protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) {
6543    if (element == null) 
6544      return;
6545    Complex t;
6546    if (Utilities.noString(parentType))
6547      t = parent;
6548    else {
6549      t = parent.predicate("fhir:"+parentType+'.'+name);
6550    }
6551    composeBackboneElement(t, "element", name, element, index);
6552    if (element.hasCodeElement()) {
6553      composeCode(t, "SourceElementComponent", "code", element.getCodeElement(), -1);
6554    }
6555    if (element.hasDisplayElement()) {
6556      composeString(t, "SourceElementComponent", "display", element.getDisplayElement(), -1);
6557    }
6558    if (element.hasNoMapElement()) {
6559      composeBoolean(t, "SourceElementComponent", "noMap", element.getNoMapElement(), -1);
6560    }
6561    for (int i = 0; i < element.getTarget().size(); i++) {
6562      composeConceptMapTargetElementComponent(t, "SourceElementComponent", "target", element.getTarget().get(i), i);
6563    }
6564  }
6565
6566  protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) {
6567    if (element == null) 
6568      return;
6569    Complex t;
6570    if (Utilities.noString(parentType))
6571      t = parent;
6572    else {
6573      t = parent.predicate("fhir:"+parentType+'.'+name);
6574    }
6575    composeBackboneElement(t, "target", name, element, index);
6576    if (element.hasCodeElement()) {
6577      composeCode(t, "TargetElementComponent", "code", element.getCodeElement(), -1);
6578    }
6579    if (element.hasDisplayElement()) {
6580      composeString(t, "TargetElementComponent", "display", element.getDisplayElement(), -1);
6581    }
6582    if (element.hasRelationshipElement()) {
6583      composeEnum(t, "TargetElementComponent", "relationship", element.getRelationshipElement(), -1);
6584    }
6585    if (element.hasCommentElement()) {
6586      composeString(t, "TargetElementComponent", "comment", element.getCommentElement(), -1);
6587    }
6588    for (int i = 0; i < element.getDependsOn().size(); i++) {
6589      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "dependsOn", element.getDependsOn().get(i), i);
6590    }
6591    for (int i = 0; i < element.getProduct().size(); i++) {
6592      composeConceptMapOtherElementComponent(t, "TargetElementComponent", "product", element.getProduct().get(i), i);
6593    }
6594  }
6595
6596  protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) {
6597    if (element == null) 
6598      return;
6599    Complex t;
6600    if (Utilities.noString(parentType))
6601      t = parent;
6602    else {
6603      t = parent.predicate("fhir:"+parentType+'.'+name);
6604    }
6605    composeBackboneElement(t, "dependsOn", name, element, index);
6606    if (element.hasPropertyElement()) {
6607      composeUri(t, "OtherElementComponent", "property", element.getPropertyElement(), -1);
6608    }
6609    if (element.hasSystemElement()) {
6610      composeCanonical(t, "OtherElementComponent", "system", element.getSystemElement(), -1);
6611    }
6612    if (element.hasValueElement()) {
6613      composeString(t, "OtherElementComponent", "value", element.getValueElement(), -1);
6614    }
6615    if (element.hasDisplayElement()) {
6616      composeString(t, "OtherElementComponent", "display", element.getDisplayElement(), -1);
6617    }
6618  }
6619
6620  protected void composeConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) {
6621    if (element == null) 
6622      return;
6623    Complex t;
6624    if (Utilities.noString(parentType))
6625      t = parent;
6626    else {
6627      t = parent.predicate("fhir:"+parentType+'.'+name);
6628    }
6629    composeBackboneElement(t, "unmapped", name, element, index);
6630    if (element.hasModeElement()) {
6631      composeEnum(t, "ConceptMapGroupUnmappedComponent", "mode", element.getModeElement(), -1);
6632    }
6633    if (element.hasCodeElement()) {
6634      composeCode(t, "ConceptMapGroupUnmappedComponent", "code", element.getCodeElement(), -1);
6635    }
6636    if (element.hasDisplayElement()) {
6637      composeString(t, "ConceptMapGroupUnmappedComponent", "display", element.getDisplayElement(), -1);
6638    }
6639    if (element.hasUrlElement()) {
6640      composeCanonical(t, "ConceptMapGroupUnmappedComponent", "url", element.getUrlElement(), -1);
6641    }
6642  }
6643
6644  protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) {
6645    if (element == null) 
6646      return;
6647    Complex t;
6648    if (Utilities.noString(parentType))
6649      t = parent;
6650    else {
6651      t = parent.predicate("fhir:"+parentType+'.'+name);
6652    }
6653    composeDomainResource(t, "Condition", name, element, index);
6654    for (int i = 0; i < element.getIdentifier().size(); i++) {
6655      composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i);
6656    }
6657    if (element.hasClinicalStatus()) {
6658      composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1);
6659    }
6660    if (element.hasVerificationStatus()) {
6661      composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1);
6662    }
6663    for (int i = 0; i < element.getCategory().size(); i++) {
6664      composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i);
6665    }
6666    if (element.hasSeverity()) {
6667      composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1);
6668    }
6669    if (element.hasCode()) {
6670      composeCodeableConcept(t, "Condition", "code", element.getCode(), -1);
6671    }
6672    for (int i = 0; i < element.getBodySite().size(); i++) {
6673      composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i);
6674    }
6675    if (element.hasSubject()) {
6676      composeReference(t, "Condition", "subject", element.getSubject(), -1);
6677    }
6678    if (element.hasEncounter()) {
6679      composeReference(t, "Condition", "encounter", element.getEncounter(), -1);
6680    }
6681    if (element.hasOnset()) {
6682      composeType(t, "Condition", "onset", element.getOnset(), -1);
6683    }
6684    if (element.hasAbatement()) {
6685      composeType(t, "Condition", "abatement", element.getAbatement(), -1);
6686    }
6687    if (element.hasRecordedDateElement()) {
6688      composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1);
6689    }
6690    if (element.hasRecorder()) {
6691      composeReference(t, "Condition", "recorder", element.getRecorder(), -1);
6692    }
6693    if (element.hasAsserter()) {
6694      composeReference(t, "Condition", "asserter", element.getAsserter(), -1);
6695    }
6696    for (int i = 0; i < element.getStage().size(); i++) {
6697      composeConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i);
6698    }
6699    for (int i = 0; i < element.getEvidence().size(); i++) {
6700      composeConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i);
6701    }
6702    for (int i = 0; i < element.getNote().size(); i++) {
6703      composeAnnotation(t, "Condition", "note", element.getNote().get(i), i);
6704    }
6705  }
6706
6707  protected void composeConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) {
6708    if (element == null) 
6709      return;
6710    Complex t;
6711    if (Utilities.noString(parentType))
6712      t = parent;
6713    else {
6714      t = parent.predicate("fhir:"+parentType+'.'+name);
6715    }
6716    composeBackboneElement(t, "stage", name, element, index);
6717    if (element.hasSummary()) {
6718      composeCodeableConcept(t, "ConditionStageComponent", "summary", element.getSummary(), -1);
6719    }
6720    for (int i = 0; i < element.getAssessment().size(); i++) {
6721      composeReference(t, "ConditionStageComponent", "assessment", element.getAssessment().get(i), i);
6722    }
6723    if (element.hasType()) {
6724      composeCodeableConcept(t, "ConditionStageComponent", "type", element.getType(), -1);
6725    }
6726  }
6727
6728  protected void composeConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) {
6729    if (element == null) 
6730      return;
6731    Complex t;
6732    if (Utilities.noString(parentType))
6733      t = parent;
6734    else {
6735      t = parent.predicate("fhir:"+parentType+'.'+name);
6736    }
6737    composeBackboneElement(t, "evidence", name, element, index);
6738    for (int i = 0; i < element.getCode().size(); i++) {
6739      composeCodeableConcept(t, "ConditionEvidenceComponent", "code", element.getCode().get(i), i);
6740    }
6741    for (int i = 0; i < element.getDetail().size(); i++) {
6742      composeReference(t, "ConditionEvidenceComponent", "detail", element.getDetail().get(i), i);
6743    }
6744  }
6745
6746  protected void composeConditionDefinition(Complex parent, String parentType, String name, ConditionDefinition element, int index) {
6747    if (element == null) 
6748      return;
6749    Complex t;
6750    if (Utilities.noString(parentType))
6751      t = parent;
6752    else {
6753      t = parent.predicate("fhir:"+parentType+'.'+name);
6754    }
6755    composeMetadataResource(t, "ConditionDefinition", name, element, index);
6756    if (element.hasUrlElement()) {
6757      composeUri(t, "ConditionDefinition", "url", element.getUrlElement(), -1);
6758    }
6759    for (int i = 0; i < element.getIdentifier().size(); i++) {
6760      composeIdentifier(t, "ConditionDefinition", "identifier", element.getIdentifier().get(i), i);
6761    }
6762    if (element.hasVersionElement()) {
6763      composeString(t, "ConditionDefinition", "version", element.getVersionElement(), -1);
6764    }
6765    if (element.hasNameElement()) {
6766      composeString(t, "ConditionDefinition", "name", element.getNameElement(), -1);
6767    }
6768    if (element.hasTitleElement()) {
6769      composeString(t, "ConditionDefinition", "title", element.getTitleElement(), -1);
6770    }
6771    if (element.hasSubtitleElement()) {
6772      composeString(t, "ConditionDefinition", "subtitle", element.getSubtitleElement(), -1);
6773    }
6774    if (element.hasStatusElement()) {
6775      composeEnum(t, "ConditionDefinition", "status", element.getStatusElement(), -1);
6776    }
6777    if (element.hasExperimentalElement()) {
6778      composeBoolean(t, "ConditionDefinition", "experimental", element.getExperimentalElement(), -1);
6779    }
6780    if (element.hasDateElement()) {
6781      composeDateTime(t, "ConditionDefinition", "date", element.getDateElement(), -1);
6782    }
6783    if (element.hasPublisherElement()) {
6784      composeString(t, "ConditionDefinition", "publisher", element.getPublisherElement(), -1);
6785    }
6786    for (int i = 0; i < element.getContact().size(); i++) {
6787      composeContactDetail(t, "ConditionDefinition", "contact", element.getContact().get(i), i);
6788    }
6789    if (element.hasDescriptionElement()) {
6790      composeMarkdown(t, "ConditionDefinition", "description", element.getDescriptionElement(), -1);
6791    }
6792    for (int i = 0; i < element.getUseContext().size(); i++) {
6793      composeUsageContext(t, "ConditionDefinition", "useContext", element.getUseContext().get(i), i);
6794    }
6795    for (int i = 0; i < element.getJurisdiction().size(); i++) {
6796      composeCodeableConcept(t, "ConditionDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
6797    }
6798    if (element.hasCode()) {
6799      composeCodeableConcept(t, "ConditionDefinition", "code", element.getCode(), -1);
6800    }
6801    if (element.hasSeverity()) {
6802      composeCodeableConcept(t, "ConditionDefinition", "severity", element.getSeverity(), -1);
6803    }
6804    if (element.hasBodySite()) {
6805      composeCodeableConcept(t, "ConditionDefinition", "bodySite", element.getBodySite(), -1);
6806    }
6807    if (element.hasStage()) {
6808      composeCodeableConcept(t, "ConditionDefinition", "stage", element.getStage(), -1);
6809    }
6810    if (element.hasHasSeverityElement()) {
6811      composeBoolean(t, "ConditionDefinition", "hasSeverity", element.getHasSeverityElement(), -1);
6812    }
6813    if (element.hasHasBodySiteElement()) {
6814      composeBoolean(t, "ConditionDefinition", "hasBodySite", element.getHasBodySiteElement(), -1);
6815    }
6816    if (element.hasHasStageElement()) {
6817      composeBoolean(t, "ConditionDefinition", "hasStage", element.getHasStageElement(), -1);
6818    }
6819    for (int i = 0; i < element.getDefinition().size(); i++) {
6820      composeUri(t, "ConditionDefinition", "definition", element.getDefinition().get(i), i);
6821    }
6822    for (int i = 0; i < element.getObservation().size(); i++) {
6823      composeConditionDefinitionObservationComponent(t, "ConditionDefinition", "observation", element.getObservation().get(i), i);
6824    }
6825    for (int i = 0; i < element.getMedication().size(); i++) {
6826      composeConditionDefinitionMedicationComponent(t, "ConditionDefinition", "medication", element.getMedication().get(i), i);
6827    }
6828    for (int i = 0; i < element.getPrecondition().size(); i++) {
6829      composeConditionDefinitionPreconditionComponent(t, "ConditionDefinition", "precondition", element.getPrecondition().get(i), i);
6830    }
6831    for (int i = 0; i < element.getTeam().size(); i++) {
6832      composeReference(t, "ConditionDefinition", "team", element.getTeam().get(i), i);
6833    }
6834    for (int i = 0; i < element.getQuestionnaire().size(); i++) {
6835      composeConditionDefinitionQuestionnaireComponent(t, "ConditionDefinition", "questionnaire", element.getQuestionnaire().get(i), i);
6836    }
6837    for (int i = 0; i < element.getPlan().size(); i++) {
6838      composeConditionDefinitionPlanComponent(t, "ConditionDefinition", "plan", element.getPlan().get(i), i);
6839    }
6840  }
6841
6842  protected void composeConditionDefinitionObservationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionObservationComponent element, int index) {
6843    if (element == null) 
6844      return;
6845    Complex t;
6846    if (Utilities.noString(parentType))
6847      t = parent;
6848    else {
6849      t = parent.predicate("fhir:"+parentType+'.'+name);
6850    }
6851    composeBackboneElement(t, "observation", name, element, index);
6852    if (element.hasCategory()) {
6853      composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "category", element.getCategory(), -1);
6854    }
6855    if (element.hasCode()) {
6856      composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "code", element.getCode(), -1);
6857    }
6858  }
6859
6860  protected void composeConditionDefinitionMedicationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionMedicationComponent element, int index) {
6861    if (element == null) 
6862      return;
6863    Complex t;
6864    if (Utilities.noString(parentType))
6865      t = parent;
6866    else {
6867      t = parent.predicate("fhir:"+parentType+'.'+name);
6868    }
6869    composeBackboneElement(t, "medication", name, element, index);
6870    if (element.hasCategory()) {
6871      composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "category", element.getCategory(), -1);
6872    }
6873    if (element.hasCode()) {
6874      composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "code", element.getCode(), -1);
6875    }
6876  }
6877
6878  protected void composeConditionDefinitionPreconditionComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPreconditionComponent element, int index) {
6879    if (element == null) 
6880      return;
6881    Complex t;
6882    if (Utilities.noString(parentType))
6883      t = parent;
6884    else {
6885      t = parent.predicate("fhir:"+parentType+'.'+name);
6886    }
6887    composeBackboneElement(t, "precondition", name, element, index);
6888    if (element.hasTypeElement()) {
6889      composeEnum(t, "ConditionDefinitionPreconditionComponent", "type", element.getTypeElement(), -1);
6890    }
6891    if (element.hasCode()) {
6892      composeCodeableConcept(t, "ConditionDefinitionPreconditionComponent", "code", element.getCode(), -1);
6893    }
6894    if (element.hasValue()) {
6895      composeType(t, "ConditionDefinitionPreconditionComponent", "value", element.getValue(), -1);
6896    }
6897  }
6898
6899  protected void composeConditionDefinitionQuestionnaireComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionQuestionnaireComponent element, int index) {
6900    if (element == null) 
6901      return;
6902    Complex t;
6903    if (Utilities.noString(parentType))
6904      t = parent;
6905    else {
6906      t = parent.predicate("fhir:"+parentType+'.'+name);
6907    }
6908    composeBackboneElement(t, "questionnaire", name, element, index);
6909    if (element.hasPurposeElement()) {
6910      composeEnum(t, "ConditionDefinitionQuestionnaireComponent", "purpose", element.getPurposeElement(), -1);
6911    }
6912    if (element.hasReference()) {
6913      composeReference(t, "ConditionDefinitionQuestionnaireComponent", "reference", element.getReference(), -1);
6914    }
6915  }
6916
6917  protected void composeConditionDefinitionPlanComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPlanComponent element, int index) {
6918    if (element == null) 
6919      return;
6920    Complex t;
6921    if (Utilities.noString(parentType))
6922      t = parent;
6923    else {
6924      t = parent.predicate("fhir:"+parentType+'.'+name);
6925    }
6926    composeBackboneElement(t, "plan", name, element, index);
6927    if (element.hasRole()) {
6928      composeCodeableConcept(t, "ConditionDefinitionPlanComponent", "role", element.getRole(), -1);
6929    }
6930    if (element.hasReference()) {
6931      composeReference(t, "ConditionDefinitionPlanComponent", "reference", element.getReference(), -1);
6932    }
6933  }
6934
6935  protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) {
6936    if (element == null) 
6937      return;
6938    Complex t;
6939    if (Utilities.noString(parentType))
6940      t = parent;
6941    else {
6942      t = parent.predicate("fhir:"+parentType+'.'+name);
6943    }
6944    composeDomainResource(t, "Consent", name, element, index);
6945    for (int i = 0; i < element.getIdentifier().size(); i++) {
6946      composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i);
6947    }
6948    if (element.hasStatusElement()) {
6949      composeEnum(t, "Consent", "status", element.getStatusElement(), -1);
6950    }
6951    if (element.hasScope()) {
6952      composeCodeableConcept(t, "Consent", "scope", element.getScope(), -1);
6953    }
6954    for (int i = 0; i < element.getCategory().size(); i++) {
6955      composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i);
6956    }
6957    if (element.hasPatient()) {
6958      composeReference(t, "Consent", "patient", element.getPatient(), -1);
6959    }
6960    if (element.hasDateTimeElement()) {
6961      composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1);
6962    }
6963    for (int i = 0; i < element.getPerformer().size(); i++) {
6964      composeReference(t, "Consent", "performer", element.getPerformer().get(i), i);
6965    }
6966    for (int i = 0; i < element.getOrganization().size(); i++) {
6967      composeReference(t, "Consent", "organization", element.getOrganization().get(i), i);
6968    }
6969    for (int i = 0; i < element.getSourceAttachment().size(); i++) {
6970      composeAttachment(t, "Consent", "sourceAttachment", element.getSourceAttachment().get(i), i);
6971    }
6972    for (int i = 0; i < element.getSourceReference().size(); i++) {
6973      composeReference(t, "Consent", "sourceReference", element.getSourceReference().get(i), i);
6974    }
6975    for (int i = 0; i < element.getPolicy().size(); i++) {
6976      composeConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i);
6977    }
6978    if (element.hasPolicyRule()) {
6979      composeCodeableConcept(t, "Consent", "policyRule", element.getPolicyRule(), -1);
6980    }
6981    for (int i = 0; i < element.getVerification().size(); i++) {
6982      composeConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i);
6983    }
6984    if (element.hasProvision()) {
6985      composeConsentProvisionComponent(t, "Consent", "provision", element.getProvision(), -1);
6986    }
6987  }
6988
6989  protected void composeConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) {
6990    if (element == null) 
6991      return;
6992    Complex t;
6993    if (Utilities.noString(parentType))
6994      t = parent;
6995    else {
6996      t = parent.predicate("fhir:"+parentType+'.'+name);
6997    }
6998    composeBackboneElement(t, "policy", name, element, index);
6999    if (element.hasAuthorityElement()) {
7000      composeUri(t, "ConsentPolicyComponent", "authority", element.getAuthorityElement(), -1);
7001    }
7002    if (element.hasUriElement()) {
7003      composeUri(t, "ConsentPolicyComponent", "uri", element.getUriElement(), -1);
7004    }
7005  }
7006
7007  protected void composeConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) {
7008    if (element == null) 
7009      return;
7010    Complex t;
7011    if (Utilities.noString(parentType))
7012      t = parent;
7013    else {
7014      t = parent.predicate("fhir:"+parentType+'.'+name);
7015    }
7016    composeBackboneElement(t, "verification", name, element, index);
7017    if (element.hasVerifiedElement()) {
7018      composeBoolean(t, "ConsentVerificationComponent", "verified", element.getVerifiedElement(), -1);
7019    }
7020    if (element.hasVerificationType()) {
7021      composeCodeableConcept(t, "ConsentVerificationComponent", "verificationType", element.getVerificationType(), -1);
7022    }
7023    if (element.hasVerifiedBy()) {
7024      composeReference(t, "ConsentVerificationComponent", "verifiedBy", element.getVerifiedBy(), -1);
7025    }
7026    if (element.hasVerifiedWith()) {
7027      composeReference(t, "ConsentVerificationComponent", "verifiedWith", element.getVerifiedWith(), -1);
7028    }
7029    for (int i = 0; i < element.getVerificationDate().size(); i++) {
7030      composeDateTime(t, "ConsentVerificationComponent", "verificationDate", element.getVerificationDate().get(i), i);
7031    }
7032  }
7033
7034  protected void composeConsentProvisionComponent(Complex parent, String parentType, String name, Consent.ProvisionComponent element, int index) {
7035    if (element == null) 
7036      return;
7037    Complex t;
7038    if (Utilities.noString(parentType))
7039      t = parent;
7040    else {
7041      t = parent.predicate("fhir:"+parentType+'.'+name);
7042    }
7043    composeBackboneElement(t, "provision", name, element, index);
7044    if (element.hasTypeElement()) {
7045      composeEnum(t, "ProvisionComponent", "type", element.getTypeElement(), -1);
7046    }
7047    if (element.hasPeriod()) {
7048      composePeriod(t, "ProvisionComponent", "period", element.getPeriod(), -1);
7049    }
7050    for (int i = 0; i < element.getActor().size(); i++) {
7051      composeConsentProvisionActorComponent(t, "ProvisionComponent", "actor", element.getActor().get(i), i);
7052    }
7053    for (int i = 0; i < element.getAction().size(); i++) {
7054      composeCodeableConcept(t, "ProvisionComponent", "action", element.getAction().get(i), i);
7055    }
7056    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
7057      composeCoding(t, "ProvisionComponent", "securityLabel", element.getSecurityLabel().get(i), i);
7058    }
7059    for (int i = 0; i < element.getPurpose().size(); i++) {
7060      composeCoding(t, "ProvisionComponent", "purpose", element.getPurpose().get(i), i);
7061    }
7062    for (int i = 0; i < element.getClass_().size(); i++) {
7063      composeCoding(t, "ProvisionComponent", "class", element.getClass_().get(i), i);
7064    }
7065    for (int i = 0; i < element.getCode().size(); i++) {
7066      composeCodeableConcept(t, "ProvisionComponent", "code", element.getCode().get(i), i);
7067    }
7068    if (element.hasDataPeriod()) {
7069      composePeriod(t, "ProvisionComponent", "dataPeriod", element.getDataPeriod(), -1);
7070    }
7071    for (int i = 0; i < element.getData().size(); i++) {
7072      composeConsentProvisionDataComponent(t, "ProvisionComponent", "data", element.getData().get(i), i);
7073    }
7074    for (int i = 0; i < element.getProvision().size(); i++) {
7075      composeConsentProvisionComponent(t, "ProvisionComponent", "provision", element.getProvision().get(i), i);
7076    }
7077  }
7078
7079  protected void composeConsentProvisionActorComponent(Complex parent, String parentType, String name, Consent.ProvisionActorComponent element, int index) {
7080    if (element == null) 
7081      return;
7082    Complex t;
7083    if (Utilities.noString(parentType))
7084      t = parent;
7085    else {
7086      t = parent.predicate("fhir:"+parentType+'.'+name);
7087    }
7088    composeBackboneElement(t, "actor", name, element, index);
7089    if (element.hasRole()) {
7090      composeCodeableConcept(t, "ProvisionActorComponent", "role", element.getRole(), -1);
7091    }
7092    if (element.hasReference()) {
7093      composeReference(t, "ProvisionActorComponent", "reference", element.getReference(), -1);
7094    }
7095  }
7096
7097  protected void composeConsentProvisionDataComponent(Complex parent, String parentType, String name, Consent.ProvisionDataComponent 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, "data", name, element, index);
7107    if (element.hasMeaningElement()) {
7108      composeEnum(t, "ProvisionDataComponent", "meaning", element.getMeaningElement(), -1);
7109    }
7110    if (element.hasReference()) {
7111      composeReference(t, "ProvisionDataComponent", "reference", element.getReference(), -1);
7112    }
7113  }
7114
7115  protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) {
7116    if (element == null) 
7117      return;
7118    Complex t;
7119    if (Utilities.noString(parentType))
7120      t = parent;
7121    else {
7122      t = parent.predicate("fhir:"+parentType+'.'+name);
7123    }
7124    composeDomainResource(t, "Contract", name, element, index);
7125    for (int i = 0; i < element.getIdentifier().size(); i++) {
7126      composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i);
7127    }
7128    if (element.hasUrlElement()) {
7129      composeUri(t, "Contract", "url", element.getUrlElement(), -1);
7130    }
7131    if (element.hasVersionElement()) {
7132      composeString(t, "Contract", "version", element.getVersionElement(), -1);
7133    }
7134    if (element.hasStatusElement()) {
7135      composeEnum(t, "Contract", "status", element.getStatusElement(), -1);
7136    }
7137    if (element.hasLegalState()) {
7138      composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1);
7139    }
7140    if (element.hasInstantiatesCanonical()) {
7141      composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1);
7142    }
7143    if (element.hasInstantiatesUriElement()) {
7144      composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1);
7145    }
7146    if (element.hasContentDerivative()) {
7147      composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1);
7148    }
7149    if (element.hasIssuedElement()) {
7150      composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1);
7151    }
7152    if (element.hasApplies()) {
7153      composePeriod(t, "Contract", "applies", element.getApplies(), -1);
7154    }
7155    if (element.hasExpirationType()) {
7156      composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1);
7157    }
7158    for (int i = 0; i < element.getSubject().size(); i++) {
7159      composeReference(t, "Contract", "subject", element.getSubject().get(i), i);
7160    }
7161    for (int i = 0; i < element.getAuthority().size(); i++) {
7162      composeReference(t, "Contract", "authority", element.getAuthority().get(i), i);
7163    }
7164    for (int i = 0; i < element.getDomain().size(); i++) {
7165      composeReference(t, "Contract", "domain", element.getDomain().get(i), i);
7166    }
7167    for (int i = 0; i < element.getSite().size(); i++) {
7168      composeReference(t, "Contract", "site", element.getSite().get(i), i);
7169    }
7170    if (element.hasNameElement()) {
7171      composeString(t, "Contract", "name", element.getNameElement(), -1);
7172    }
7173    if (element.hasTitleElement()) {
7174      composeString(t, "Contract", "title", element.getTitleElement(), -1);
7175    }
7176    if (element.hasSubtitleElement()) {
7177      composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1);
7178    }
7179    for (int i = 0; i < element.getAlias().size(); i++) {
7180      composeString(t, "Contract", "alias", element.getAlias().get(i), i);
7181    }
7182    if (element.hasAuthor()) {
7183      composeReference(t, "Contract", "author", element.getAuthor(), -1);
7184    }
7185    if (element.hasScope()) {
7186      composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1);
7187    }
7188    if (element.hasTopic()) {
7189      composeType(t, "Contract", "topic", element.getTopic(), -1);
7190    }
7191    if (element.hasType()) {
7192      composeCodeableConcept(t, "Contract", "type", element.getType(), -1);
7193    }
7194    for (int i = 0; i < element.getSubType().size(); i++) {
7195      composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i);
7196    }
7197    if (element.hasContentDefinition()) {
7198      composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1);
7199    }
7200    for (int i = 0; i < element.getTerm().size(); i++) {
7201      composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i);
7202    }
7203    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
7204      composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i);
7205    }
7206    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
7207      composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i);
7208    }
7209    for (int i = 0; i < element.getSigner().size(); i++) {
7210      composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i);
7211    }
7212    for (int i = 0; i < element.getFriendly().size(); i++) {
7213      composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i);
7214    }
7215    for (int i = 0; i < element.getLegal().size(); i++) {
7216      composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i);
7217    }
7218    for (int i = 0; i < element.getRule().size(); i++) {
7219      composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i);
7220    }
7221    if (element.hasLegallyBinding()) {
7222      composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1);
7223    }
7224  }
7225
7226  protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent element, int index) {
7227    if (element == null) 
7228      return;
7229    Complex t;
7230    if (Utilities.noString(parentType))
7231      t = parent;
7232    else {
7233      t = parent.predicate("fhir:"+parentType+'.'+name);
7234    }
7235    composeBackboneElement(t, "contentDefinition", name, element, index);
7236    if (element.hasType()) {
7237      composeCodeableConcept(t, "ContentDefinitionComponent", "type", element.getType(), -1);
7238    }
7239    if (element.hasSubType()) {
7240      composeCodeableConcept(t, "ContentDefinitionComponent", "subType", element.getSubType(), -1);
7241    }
7242    if (element.hasPublisher()) {
7243      composeReference(t, "ContentDefinitionComponent", "publisher", element.getPublisher(), -1);
7244    }
7245    if (element.hasPublicationDateElement()) {
7246      composeDateTime(t, "ContentDefinitionComponent", "publicationDate", element.getPublicationDateElement(), -1);
7247    }
7248    if (element.hasPublicationStatusElement()) {
7249      composeEnum(t, "ContentDefinitionComponent", "publicationStatus", element.getPublicationStatusElement(), -1);
7250    }
7251    if (element.hasCopyrightElement()) {
7252      composeMarkdown(t, "ContentDefinitionComponent", "copyright", element.getCopyrightElement(), -1);
7253    }
7254  }
7255
7256  protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) {
7257    if (element == null) 
7258      return;
7259    Complex t;
7260    if (Utilities.noString(parentType))
7261      t = parent;
7262    else {
7263      t = parent.predicate("fhir:"+parentType+'.'+name);
7264    }
7265    composeBackboneElement(t, "term", name, element, index);
7266    if (element.hasIdentifier()) {
7267      composeIdentifier(t, "TermComponent", "identifier", element.getIdentifier(), -1);
7268    }
7269    if (element.hasIssuedElement()) {
7270      composeDateTime(t, "TermComponent", "issued", element.getIssuedElement(), -1);
7271    }
7272    if (element.hasApplies()) {
7273      composePeriod(t, "TermComponent", "applies", element.getApplies(), -1);
7274    }
7275    if (element.hasTopic()) {
7276      composeType(t, "TermComponent", "topic", element.getTopic(), -1);
7277    }
7278    if (element.hasType()) {
7279      composeCodeableConcept(t, "TermComponent", "type", element.getType(), -1);
7280    }
7281    if (element.hasSubType()) {
7282      composeCodeableConcept(t, "TermComponent", "subType", element.getSubType(), -1);
7283    }
7284    if (element.hasTextElement()) {
7285      composeString(t, "TermComponent", "text", element.getTextElement(), -1);
7286    }
7287    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
7288      composeContractSecurityLabelComponent(t, "TermComponent", "securityLabel", element.getSecurityLabel().get(i), i);
7289    }
7290    if (element.hasOffer()) {
7291      composeContractOfferComponent(t, "TermComponent", "offer", element.getOffer(), -1);
7292    }
7293    for (int i = 0; i < element.getAsset().size(); i++) {
7294      composeContractAssetComponent(t, "TermComponent", "asset", element.getAsset().get(i), i);
7295    }
7296    for (int i = 0; i < element.getAction().size(); i++) {
7297      composeContractActionComponent(t, "TermComponent", "action", element.getAction().get(i), i);
7298    }
7299    for (int i = 0; i < element.getGroup().size(); i++) {
7300      composeContractTermComponent(t, "TermComponent", "group", element.getGroup().get(i), i);
7301    }
7302  }
7303
7304  protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) {
7305    if (element == null) 
7306      return;
7307    Complex t;
7308    if (Utilities.noString(parentType))
7309      t = parent;
7310    else {
7311      t = parent.predicate("fhir:"+parentType+'.'+name);
7312    }
7313    composeBackboneElement(t, "securityLabel", name, element, index);
7314    for (int i = 0; i < element.getNumber().size(); i++) {
7315      composeUnsignedInt(t, "SecurityLabelComponent", "number", element.getNumber().get(i), i);
7316    }
7317    if (element.hasClassification()) {
7318      composeCoding(t, "SecurityLabelComponent", "classification", element.getClassification(), -1);
7319    }
7320    for (int i = 0; i < element.getCategory().size(); i++) {
7321      composeCoding(t, "SecurityLabelComponent", "category", element.getCategory().get(i), i);
7322    }
7323    for (int i = 0; i < element.getControl().size(); i++) {
7324      composeCoding(t, "SecurityLabelComponent", "control", element.getControl().get(i), i);
7325    }
7326  }
7327
7328  protected void composeContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent element, int index) {
7329    if (element == null) 
7330      return;
7331    Complex t;
7332    if (Utilities.noString(parentType))
7333      t = parent;
7334    else {
7335      t = parent.predicate("fhir:"+parentType+'.'+name);
7336    }
7337    composeBackboneElement(t, "offer", name, element, index);
7338    for (int i = 0; i < element.getIdentifier().size(); i++) {
7339      composeIdentifier(t, "ContractOfferComponent", "identifier", element.getIdentifier().get(i), i);
7340    }
7341    for (int i = 0; i < element.getParty().size(); i++) {
7342      composeContractPartyComponent(t, "ContractOfferComponent", "party", element.getParty().get(i), i);
7343    }
7344    if (element.hasTopic()) {
7345      composeReference(t, "ContractOfferComponent", "topic", element.getTopic(), -1);
7346    }
7347    if (element.hasType()) {
7348      composeCodeableConcept(t, "ContractOfferComponent", "type", element.getType(), -1);
7349    }
7350    if (element.hasDecision()) {
7351      composeCodeableConcept(t, "ContractOfferComponent", "decision", element.getDecision(), -1);
7352    }
7353    for (int i = 0; i < element.getDecisionMode().size(); i++) {
7354      composeCodeableConcept(t, "ContractOfferComponent", "decisionMode", element.getDecisionMode().get(i), i);
7355    }
7356    for (int i = 0; i < element.getAnswer().size(); i++) {
7357      composeContractAnswerComponent(t, "ContractOfferComponent", "answer", element.getAnswer().get(i), i);
7358    }
7359    if (element.hasTextElement()) {
7360      composeString(t, "ContractOfferComponent", "text", element.getTextElement(), -1);
7361    }
7362    for (int i = 0; i < element.getLinkId().size(); i++) {
7363      composeString(t, "ContractOfferComponent", "linkId", element.getLinkId().get(i), i);
7364    }
7365    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7366      composeUnsignedInt(t, "ContractOfferComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7367    }
7368  }
7369
7370  protected void composeContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent element, int index) {
7371    if (element == null) 
7372      return;
7373    Complex t;
7374    if (Utilities.noString(parentType))
7375      t = parent;
7376    else {
7377      t = parent.predicate("fhir:"+parentType+'.'+name);
7378    }
7379    composeBackboneElement(t, "party", name, element, index);
7380    for (int i = 0; i < element.getReference().size(); i++) {
7381      composeReference(t, "ContractPartyComponent", "reference", element.getReference().get(i), i);
7382    }
7383    if (element.hasRole()) {
7384      composeCodeableConcept(t, "ContractPartyComponent", "role", element.getRole(), -1);
7385    }
7386  }
7387
7388  protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) {
7389    if (element == null) 
7390      return;
7391    Complex t;
7392    if (Utilities.noString(parentType))
7393      t = parent;
7394    else {
7395      t = parent.predicate("fhir:"+parentType+'.'+name);
7396    }
7397    composeBackboneElement(t, "answer", name, element, index);
7398    if (element.hasValue()) {
7399      composeType(t, "AnswerComponent", "value", element.getValue(), -1);
7400    }
7401  }
7402
7403  protected void composeContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) {
7404    if (element == null) 
7405      return;
7406    Complex t;
7407    if (Utilities.noString(parentType))
7408      t = parent;
7409    else {
7410      t = parent.predicate("fhir:"+parentType+'.'+name);
7411    }
7412    composeBackboneElement(t, "asset", name, element, index);
7413    if (element.hasScope()) {
7414      composeCodeableConcept(t, "ContractAssetComponent", "scope", element.getScope(), -1);
7415    }
7416    for (int i = 0; i < element.getType().size(); i++) {
7417      composeCodeableConcept(t, "ContractAssetComponent", "type", element.getType().get(i), i);
7418    }
7419    for (int i = 0; i < element.getTypeReference().size(); i++) {
7420      composeReference(t, "ContractAssetComponent", "typeReference", element.getTypeReference().get(i), i);
7421    }
7422    for (int i = 0; i < element.getSubtype().size(); i++) {
7423      composeCodeableConcept(t, "ContractAssetComponent", "subtype", element.getSubtype().get(i), i);
7424    }
7425    if (element.hasRelationship()) {
7426      composeCoding(t, "ContractAssetComponent", "relationship", element.getRelationship(), -1);
7427    }
7428    for (int i = 0; i < element.getContext().size(); i++) {
7429      composeContractAssetContextComponent(t, "ContractAssetComponent", "context", element.getContext().get(i), i);
7430    }
7431    if (element.hasConditionElement()) {
7432      composeString(t, "ContractAssetComponent", "condition", element.getConditionElement(), -1);
7433    }
7434    for (int i = 0; i < element.getPeriodType().size(); i++) {
7435      composeCodeableConcept(t, "ContractAssetComponent", "periodType", element.getPeriodType().get(i), i);
7436    }
7437    for (int i = 0; i < element.getPeriod().size(); i++) {
7438      composePeriod(t, "ContractAssetComponent", "period", element.getPeriod().get(i), i);
7439    }
7440    for (int i = 0; i < element.getUsePeriod().size(); i++) {
7441      composePeriod(t, "ContractAssetComponent", "usePeriod", element.getUsePeriod().get(i), i);
7442    }
7443    if (element.hasTextElement()) {
7444      composeString(t, "ContractAssetComponent", "text", element.getTextElement(), -1);
7445    }
7446    for (int i = 0; i < element.getLinkId().size(); i++) {
7447      composeString(t, "ContractAssetComponent", "linkId", element.getLinkId().get(i), i);
7448    }
7449    for (int i = 0; i < element.getAnswer().size(); i++) {
7450      composeContractAnswerComponent(t, "ContractAssetComponent", "answer", element.getAnswer().get(i), i);
7451    }
7452    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7453      composeUnsignedInt(t, "ContractAssetComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7454    }
7455    for (int i = 0; i < element.getValuedItem().size(); i++) {
7456      composeContractValuedItemComponent(t, "ContractAssetComponent", "valuedItem", element.getValuedItem().get(i), i);
7457    }
7458  }
7459
7460  protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) {
7461    if (element == null) 
7462      return;
7463    Complex t;
7464    if (Utilities.noString(parentType))
7465      t = parent;
7466    else {
7467      t = parent.predicate("fhir:"+parentType+'.'+name);
7468    }
7469    composeBackboneElement(t, "context", name, element, index);
7470    if (element.hasReference()) {
7471      composeReference(t, "AssetContextComponent", "reference", element.getReference(), -1);
7472    }
7473    for (int i = 0; i < element.getCode().size(); i++) {
7474      composeCodeableConcept(t, "AssetContextComponent", "code", element.getCode().get(i), i);
7475    }
7476    if (element.hasTextElement()) {
7477      composeString(t, "AssetContextComponent", "text", element.getTextElement(), -1);
7478    }
7479  }
7480
7481  protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent 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, "valuedItem", name, element, index);
7491    if (element.hasEntity()) {
7492      composeType(t, "ValuedItemComponent", "entity", element.getEntity(), -1);
7493    }
7494    if (element.hasIdentifier()) {
7495      composeIdentifier(t, "ValuedItemComponent", "identifier", element.getIdentifier(), -1);
7496    }
7497    if (element.hasEffectiveTimeElement()) {
7498      composeDateTime(t, "ValuedItemComponent", "effectiveTime", element.getEffectiveTimeElement(), -1);
7499    }
7500    if (element.hasQuantity()) {
7501      composeQuantity(t, "ValuedItemComponent", "quantity", element.getQuantity(), -1);
7502    }
7503    if (element.hasUnitPrice()) {
7504      composeMoney(t, "ValuedItemComponent", "unitPrice", element.getUnitPrice(), -1);
7505    }
7506    if (element.hasFactorElement()) {
7507      composeDecimal(t, "ValuedItemComponent", "factor", element.getFactorElement(), -1);
7508    }
7509    if (element.hasPointsElement()) {
7510      composeDecimal(t, "ValuedItemComponent", "points", element.getPointsElement(), -1);
7511    }
7512    if (element.hasNet()) {
7513      composeMoney(t, "ValuedItemComponent", "net", element.getNet(), -1);
7514    }
7515    if (element.hasPaymentElement()) {
7516      composeString(t, "ValuedItemComponent", "payment", element.getPaymentElement(), -1);
7517    }
7518    if (element.hasPaymentDateElement()) {
7519      composeDateTime(t, "ValuedItemComponent", "paymentDate", element.getPaymentDateElement(), -1);
7520    }
7521    if (element.hasResponsible()) {
7522      composeReference(t, "ValuedItemComponent", "responsible", element.getResponsible(), -1);
7523    }
7524    if (element.hasRecipient()) {
7525      composeReference(t, "ValuedItemComponent", "recipient", element.getRecipient(), -1);
7526    }
7527    for (int i = 0; i < element.getLinkId().size(); i++) {
7528      composeString(t, "ValuedItemComponent", "linkId", element.getLinkId().get(i), i);
7529    }
7530    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7531      composeUnsignedInt(t, "ValuedItemComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7532    }
7533  }
7534
7535  protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent 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, "action", name, element, index);
7545    if (element.hasDoNotPerformElement()) {
7546      composeBoolean(t, "ActionComponent", "doNotPerform", element.getDoNotPerformElement(), -1);
7547    }
7548    if (element.hasType()) {
7549      composeCodeableConcept(t, "ActionComponent", "type", element.getType(), -1);
7550    }
7551    for (int i = 0; i < element.getSubject().size(); i++) {
7552      composeContractActionSubjectComponent(t, "ActionComponent", "subject", element.getSubject().get(i), i);
7553    }
7554    if (element.hasIntent()) {
7555      composeCodeableConcept(t, "ActionComponent", "intent", element.getIntent(), -1);
7556    }
7557    for (int i = 0; i < element.getLinkId().size(); i++) {
7558      composeString(t, "ActionComponent", "linkId", element.getLinkId().get(i), i);
7559    }
7560    if (element.hasStatus()) {
7561      composeCodeableConcept(t, "ActionComponent", "status", element.getStatus(), -1);
7562    }
7563    if (element.hasContext()) {
7564      composeReference(t, "ActionComponent", "context", element.getContext(), -1);
7565    }
7566    for (int i = 0; i < element.getContextLinkId().size(); i++) {
7567      composeString(t, "ActionComponent", "contextLinkId", element.getContextLinkId().get(i), i);
7568    }
7569    if (element.hasOccurrence()) {
7570      composeType(t, "ActionComponent", "occurrence", element.getOccurrence(), -1);
7571    }
7572    for (int i = 0; i < element.getRequester().size(); i++) {
7573      composeReference(t, "ActionComponent", "requester", element.getRequester().get(i), i);
7574    }
7575    for (int i = 0; i < element.getRequesterLinkId().size(); i++) {
7576      composeString(t, "ActionComponent", "requesterLinkId", element.getRequesterLinkId().get(i), i);
7577    }
7578    for (int i = 0; i < element.getPerformerType().size(); i++) {
7579      composeCodeableConcept(t, "ActionComponent", "performerType", element.getPerformerType().get(i), i);
7580    }
7581    if (element.hasPerformerRole()) {
7582      composeCodeableConcept(t, "ActionComponent", "performerRole", element.getPerformerRole(), -1);
7583    }
7584    if (element.hasPerformer()) {
7585      composeReference(t, "ActionComponent", "performer", element.getPerformer(), -1);
7586    }
7587    for (int i = 0; i < element.getPerformerLinkId().size(); i++) {
7588      composeString(t, "ActionComponent", "performerLinkId", element.getPerformerLinkId().get(i), i);
7589    }
7590    for (int i = 0; i < element.getReason().size(); i++) {
7591      composeCodeableReference(t, "ActionComponent", "reason", element.getReason().get(i), i);
7592    }
7593    for (int i = 0; i < element.getReasonLinkId().size(); i++) {
7594      composeString(t, "ActionComponent", "reasonLinkId", element.getReasonLinkId().get(i), i);
7595    }
7596    for (int i = 0; i < element.getNote().size(); i++) {
7597      composeAnnotation(t, "ActionComponent", "note", element.getNote().get(i), i);
7598    }
7599    for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) {
7600      composeUnsignedInt(t, "ActionComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i);
7601    }
7602  }
7603
7604  protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) {
7605    if (element == null) 
7606      return;
7607    Complex t;
7608    if (Utilities.noString(parentType))
7609      t = parent;
7610    else {
7611      t = parent.predicate("fhir:"+parentType+'.'+name);
7612    }
7613    composeBackboneElement(t, "subject", name, element, index);
7614    for (int i = 0; i < element.getReference().size(); i++) {
7615      composeReference(t, "ActionSubjectComponent", "reference", element.getReference().get(i), i);
7616    }
7617    if (element.hasRole()) {
7618      composeCodeableConcept(t, "ActionSubjectComponent", "role", element.getRole(), -1);
7619    }
7620  }
7621
7622  protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) {
7623    if (element == null) 
7624      return;
7625    Complex t;
7626    if (Utilities.noString(parentType))
7627      t = parent;
7628    else {
7629      t = parent.predicate("fhir:"+parentType+'.'+name);
7630    }
7631    composeBackboneElement(t, "signer", name, element, index);
7632    if (element.hasType()) {
7633      composeCoding(t, "SignatoryComponent", "type", element.getType(), -1);
7634    }
7635    if (element.hasParty()) {
7636      composeReference(t, "SignatoryComponent", "party", element.getParty(), -1);
7637    }
7638    for (int i = 0; i < element.getSignature().size(); i++) {
7639      composeSignature(t, "SignatoryComponent", "signature", element.getSignature().get(i), i);
7640    }
7641  }
7642
7643  protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) {
7644    if (element == null) 
7645      return;
7646    Complex t;
7647    if (Utilities.noString(parentType))
7648      t = parent;
7649    else {
7650      t = parent.predicate("fhir:"+parentType+'.'+name);
7651    }
7652    composeBackboneElement(t, "friendly", name, element, index);
7653    if (element.hasContent()) {
7654      composeType(t, "FriendlyLanguageComponent", "content", element.getContent(), -1);
7655    }
7656  }
7657
7658  protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) {
7659    if (element == null) 
7660      return;
7661    Complex t;
7662    if (Utilities.noString(parentType))
7663      t = parent;
7664    else {
7665      t = parent.predicate("fhir:"+parentType+'.'+name);
7666    }
7667    composeBackboneElement(t, "legal", name, element, index);
7668    if (element.hasContent()) {
7669      composeType(t, "LegalLanguageComponent", "content", element.getContent(), -1);
7670    }
7671  }
7672
7673  protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) {
7674    if (element == null) 
7675      return;
7676    Complex t;
7677    if (Utilities.noString(parentType))
7678      t = parent;
7679    else {
7680      t = parent.predicate("fhir:"+parentType+'.'+name);
7681    }
7682    composeBackboneElement(t, "rule", name, element, index);
7683    if (element.hasContent()) {
7684      composeType(t, "ComputableLanguageComponent", "content", element.getContent(), -1);
7685    }
7686  }
7687
7688  protected void composeCoverage(Complex parent, String parentType, String name, Coverage 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, "Coverage", name, element, index);
7698    for (int i = 0; i < element.getIdentifier().size(); i++) {
7699      composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i);
7700    }
7701    if (element.hasStatusElement()) {
7702      composeEnum(t, "Coverage", "status", element.getStatusElement(), -1);
7703    }
7704    if (element.hasType()) {
7705      composeCodeableConcept(t, "Coverage", "type", element.getType(), -1);
7706    }
7707    if (element.hasPolicyHolder()) {
7708      composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1);
7709    }
7710    if (element.hasSubscriber()) {
7711      composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1);
7712    }
7713    if (element.hasSubscriberId()) {
7714      composeIdentifier(t, "Coverage", "subscriberId", element.getSubscriberId(), -1);
7715    }
7716    if (element.hasBeneficiary()) {
7717      composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1);
7718    }
7719    if (element.hasDependentElement()) {
7720      composeString(t, "Coverage", "dependent", element.getDependentElement(), -1);
7721    }
7722    if (element.hasRelationship()) {
7723      composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1);
7724    }
7725    if (element.hasPeriod()) {
7726      composePeriod(t, "Coverage", "period", element.getPeriod(), -1);
7727    }
7728    for (int i = 0; i < element.getPayor().size(); i++) {
7729      composeReference(t, "Coverage", "payor", element.getPayor().get(i), i);
7730    }
7731    for (int i = 0; i < element.getClass_().size(); i++) {
7732      composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i);
7733    }
7734    if (element.hasOrderElement()) {
7735      composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1);
7736    }
7737    if (element.hasNetworkElement()) {
7738      composeString(t, "Coverage", "network", element.getNetworkElement(), -1);
7739    }
7740    for (int i = 0; i < element.getCostToBeneficiary().size(); i++) {
7741      composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i);
7742    }
7743    if (element.hasSubrogationElement()) {
7744      composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1);
7745    }
7746    for (int i = 0; i < element.getContract().size(); i++) {
7747      composeReference(t, "Coverage", "contract", element.getContract().get(i), i);
7748    }
7749  }
7750
7751  protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) {
7752    if (element == null) 
7753      return;
7754    Complex t;
7755    if (Utilities.noString(parentType))
7756      t = parent;
7757    else {
7758      t = parent.predicate("fhir:"+parentType+'.'+name);
7759    }
7760    composeBackboneElement(t, "class", name, element, index);
7761    if (element.hasType()) {
7762      composeCodeableConcept(t, "ClassComponent", "type", element.getType(), -1);
7763    }
7764    if (element.hasValueElement()) {
7765      composeString(t, "ClassComponent", "value", element.getValueElement(), -1);
7766    }
7767    if (element.hasNameElement()) {
7768      composeString(t, "ClassComponent", "name", element.getNameElement(), -1);
7769    }
7770  }
7771
7772  protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) {
7773    if (element == null) 
7774      return;
7775    Complex t;
7776    if (Utilities.noString(parentType))
7777      t = parent;
7778    else {
7779      t = parent.predicate("fhir:"+parentType+'.'+name);
7780    }
7781    composeBackboneElement(t, "costToBeneficiary", name, element, index);
7782    if (element.hasType()) {
7783      composeCodeableConcept(t, "CostToBeneficiaryComponent", "type", element.getType(), -1);
7784    }
7785    if (element.hasValue()) {
7786      composeType(t, "CostToBeneficiaryComponent", "value", element.getValue(), -1);
7787    }
7788    for (int i = 0; i < element.getException().size(); i++) {
7789      composeCoverageExemptionComponent(t, "CostToBeneficiaryComponent", "exception", element.getException().get(i), i);
7790    }
7791  }
7792
7793  protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) {
7794    if (element == null) 
7795      return;
7796    Complex t;
7797    if (Utilities.noString(parentType))
7798      t = parent;
7799    else {
7800      t = parent.predicate("fhir:"+parentType+'.'+name);
7801    }
7802    composeBackboneElement(t, "exception", name, element, index);
7803    if (element.hasType()) {
7804      composeCodeableConcept(t, "ExemptionComponent", "type", element.getType(), -1);
7805    }
7806    if (element.hasPeriod()) {
7807      composePeriod(t, "ExemptionComponent", "period", element.getPeriod(), -1);
7808    }
7809  }
7810
7811  protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) {
7812    if (element == null) 
7813      return;
7814    Complex t;
7815    if (Utilities.noString(parentType))
7816      t = parent;
7817    else {
7818      t = parent.predicate("fhir:"+parentType+'.'+name);
7819    }
7820    composeDomainResource(t, "CoverageEligibilityRequest", name, element, index);
7821    for (int i = 0; i < element.getIdentifier().size(); i++) {
7822      composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i);
7823    }
7824    if (element.hasStatusElement()) {
7825      composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1);
7826    }
7827    if (element.hasPriority()) {
7828      composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1);
7829    }
7830    for (int i = 0; i < element.getPurpose().size(); i++) {
7831      composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i);
7832    }
7833    if (element.hasPatient()) {
7834      composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1);
7835    }
7836    if (element.hasServiced()) {
7837      composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1);
7838    }
7839    if (element.hasCreatedElement()) {
7840      composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1);
7841    }
7842    if (element.hasEnterer()) {
7843      composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1);
7844    }
7845    if (element.hasProvider()) {
7846      composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1);
7847    }
7848    if (element.hasInsurer()) {
7849      composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1);
7850    }
7851    if (element.hasFacility()) {
7852      composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1);
7853    }
7854    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
7855      composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
7856    }
7857    for (int i = 0; i < element.getInsurance().size(); i++) {
7858      composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i);
7859    }
7860    for (int i = 0; i < element.getItem().size(); i++) {
7861      composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i);
7862    }
7863  }
7864
7865  protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) {
7866    if (element == null) 
7867      return;
7868    Complex t;
7869    if (Utilities.noString(parentType))
7870      t = parent;
7871    else {
7872      t = parent.predicate("fhir:"+parentType+'.'+name);
7873    }
7874    composeBackboneElement(t, "supportingInfo", name, element, index);
7875    if (element.hasSequenceElement()) {
7876      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
7877    }
7878    if (element.hasInformation()) {
7879      composeReference(t, "SupportingInformationComponent", "information", element.getInformation(), -1);
7880    }
7881    if (element.hasAppliesToAllElement()) {
7882      composeBoolean(t, "SupportingInformationComponent", "appliesToAll", element.getAppliesToAllElement(), -1);
7883    }
7884  }
7885
7886  protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent element, int index) {
7887    if (element == null) 
7888      return;
7889    Complex t;
7890    if (Utilities.noString(parentType))
7891      t = parent;
7892    else {
7893      t = parent.predicate("fhir:"+parentType+'.'+name);
7894    }
7895    composeBackboneElement(t, "insurance", name, element, index);
7896    if (element.hasFocalElement()) {
7897      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
7898    }
7899    if (element.hasCoverage()) {
7900      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
7901    }
7902    if (element.hasBusinessArrangementElement()) {
7903      composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1);
7904    }
7905  }
7906
7907  protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) {
7908    if (element == null) 
7909      return;
7910    Complex t;
7911    if (Utilities.noString(parentType))
7912      t = parent;
7913    else {
7914      t = parent.predicate("fhir:"+parentType+'.'+name);
7915    }
7916    composeBackboneElement(t, "item", name, element, index);
7917    for (int i = 0; i < element.getSupportingInfoSequence().size(); i++) {
7918      composePositiveInt(t, "DetailsComponent", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i);
7919    }
7920    if (element.hasCategory()) {
7921      composeCodeableConcept(t, "DetailsComponent", "category", element.getCategory(), -1);
7922    }
7923    if (element.hasProductOrService()) {
7924      composeCodeableConcept(t, "DetailsComponent", "productOrService", element.getProductOrService(), -1);
7925    }
7926    for (int i = 0; i < element.getModifier().size(); i++) {
7927      composeCodeableConcept(t, "DetailsComponent", "modifier", element.getModifier().get(i), i);
7928    }
7929    if (element.hasProvider()) {
7930      composeReference(t, "DetailsComponent", "provider", element.getProvider(), -1);
7931    }
7932    if (element.hasQuantity()) {
7933      composeQuantity(t, "DetailsComponent", "quantity", element.getQuantity(), -1);
7934    }
7935    if (element.hasUnitPrice()) {
7936      composeMoney(t, "DetailsComponent", "unitPrice", element.getUnitPrice(), -1);
7937    }
7938    if (element.hasFacility()) {
7939      composeReference(t, "DetailsComponent", "facility", element.getFacility(), -1);
7940    }
7941    for (int i = 0; i < element.getDiagnosis().size(); i++) {
7942      composeCoverageEligibilityRequestDiagnosisComponent(t, "DetailsComponent", "diagnosis", element.getDiagnosis().get(i), i);
7943    }
7944    for (int i = 0; i < element.getDetail().size(); i++) {
7945      composeReference(t, "DetailsComponent", "detail", element.getDetail().get(i), i);
7946    }
7947  }
7948
7949  protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) {
7950    if (element == null) 
7951      return;
7952    Complex t;
7953    if (Utilities.noString(parentType))
7954      t = parent;
7955    else {
7956      t = parent.predicate("fhir:"+parentType+'.'+name);
7957    }
7958    composeBackboneElement(t, "diagnosis", name, element, index);
7959    if (element.hasDiagnosis()) {
7960      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
7961    }
7962  }
7963
7964  protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) {
7965    if (element == null) 
7966      return;
7967    Complex t;
7968    if (Utilities.noString(parentType))
7969      t = parent;
7970    else {
7971      t = parent.predicate("fhir:"+parentType+'.'+name);
7972    }
7973    composeDomainResource(t, "CoverageEligibilityResponse", name, element, index);
7974    for (int i = 0; i < element.getIdentifier().size(); i++) {
7975      composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i);
7976    }
7977    if (element.hasStatusElement()) {
7978      composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1);
7979    }
7980    for (int i = 0; i < element.getPurpose().size(); i++) {
7981      composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i);
7982    }
7983    if (element.hasPatient()) {
7984      composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1);
7985    }
7986    if (element.hasServiced()) {
7987      composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1);
7988    }
7989    if (element.hasCreatedElement()) {
7990      composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1);
7991    }
7992    if (element.hasRequestor()) {
7993      composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1);
7994    }
7995    if (element.hasRequest()) {
7996      composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1);
7997    }
7998    if (element.hasOutcomeElement()) {
7999      composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1);
8000    }
8001    if (element.hasDispositionElement()) {
8002      composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1);
8003    }
8004    if (element.hasInsurer()) {
8005      composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1);
8006    }
8007    for (int i = 0; i < element.getInsurance().size(); i++) {
8008      composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i);
8009    }
8010    if (element.hasPreAuthRefElement()) {
8011      composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1);
8012    }
8013    if (element.hasForm()) {
8014      composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1);
8015    }
8016    for (int i = 0; i < element.getError().size(); i++) {
8017      composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i);
8018    }
8019  }
8020
8021  protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) {
8022    if (element == null) 
8023      return;
8024    Complex t;
8025    if (Utilities.noString(parentType))
8026      t = parent;
8027    else {
8028      t = parent.predicate("fhir:"+parentType+'.'+name);
8029    }
8030    composeBackboneElement(t, "insurance", name, element, index);
8031    if (element.hasCoverage()) {
8032      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
8033    }
8034    if (element.hasInforceElement()) {
8035      composeBoolean(t, "InsuranceComponent", "inforce", element.getInforceElement(), -1);
8036    }
8037    if (element.hasBenefitPeriod()) {
8038      composePeriod(t, "InsuranceComponent", "benefitPeriod", element.getBenefitPeriod(), -1);
8039    }
8040    for (int i = 0; i < element.getItem().size(); i++) {
8041      composeCoverageEligibilityResponseItemsComponent(t, "InsuranceComponent", "item", element.getItem().get(i), i);
8042    }
8043  }
8044
8045  protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) {
8046    if (element == null) 
8047      return;
8048    Complex t;
8049    if (Utilities.noString(parentType))
8050      t = parent;
8051    else {
8052      t = parent.predicate("fhir:"+parentType+'.'+name);
8053    }
8054    composeBackboneElement(t, "item", name, element, index);
8055    if (element.hasCategory()) {
8056      composeCodeableConcept(t, "ItemsComponent", "category", element.getCategory(), -1);
8057    }
8058    if (element.hasProductOrService()) {
8059      composeCodeableConcept(t, "ItemsComponent", "productOrService", element.getProductOrService(), -1);
8060    }
8061    for (int i = 0; i < element.getModifier().size(); i++) {
8062      composeCodeableConcept(t, "ItemsComponent", "modifier", element.getModifier().get(i), i);
8063    }
8064    if (element.hasProvider()) {
8065      composeReference(t, "ItemsComponent", "provider", element.getProvider(), -1);
8066    }
8067    if (element.hasExcludedElement()) {
8068      composeBoolean(t, "ItemsComponent", "excluded", element.getExcludedElement(), -1);
8069    }
8070    if (element.hasNameElement()) {
8071      composeString(t, "ItemsComponent", "name", element.getNameElement(), -1);
8072    }
8073    if (element.hasDescriptionElement()) {
8074      composeString(t, "ItemsComponent", "description", element.getDescriptionElement(), -1);
8075    }
8076    if (element.hasNetwork()) {
8077      composeCodeableConcept(t, "ItemsComponent", "network", element.getNetwork(), -1);
8078    }
8079    if (element.hasUnit()) {
8080      composeCodeableConcept(t, "ItemsComponent", "unit", element.getUnit(), -1);
8081    }
8082    if (element.hasTerm()) {
8083      composeCodeableConcept(t, "ItemsComponent", "term", element.getTerm(), -1);
8084    }
8085    for (int i = 0; i < element.getBenefit().size(); i++) {
8086      composeCoverageEligibilityResponseBenefitComponent(t, "ItemsComponent", "benefit", element.getBenefit().get(i), i);
8087    }
8088    if (element.hasAuthorizationRequiredElement()) {
8089      composeBoolean(t, "ItemsComponent", "authorizationRequired", element.getAuthorizationRequiredElement(), -1);
8090    }
8091    for (int i = 0; i < element.getAuthorizationSupporting().size(); i++) {
8092      composeCodeableConcept(t, "ItemsComponent", "authorizationSupporting", element.getAuthorizationSupporting().get(i), i);
8093    }
8094    if (element.hasAuthorizationUrlElement()) {
8095      composeUri(t, "ItemsComponent", "authorizationUrl", element.getAuthorizationUrlElement(), -1);
8096    }
8097  }
8098
8099  protected void composeCoverageEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.BenefitComponent 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    composeBackboneElement(t, "benefit", name, element, index);
8109    if (element.hasType()) {
8110      composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1);
8111    }
8112    if (element.hasAllowed()) {
8113      composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1);
8114    }
8115    if (element.hasUsed()) {
8116      composeType(t, "BenefitComponent", "used", element.getUsed(), -1);
8117    }
8118  }
8119
8120  protected void composeCoverageEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ErrorsComponent element, int index) {
8121    if (element == null) 
8122      return;
8123    Complex t;
8124    if (Utilities.noString(parentType))
8125      t = parent;
8126    else {
8127      t = parent.predicate("fhir:"+parentType+'.'+name);
8128    }
8129    composeBackboneElement(t, "error", name, element, index);
8130    if (element.hasCode()) {
8131      composeCodeableConcept(t, "ErrorsComponent", "code", element.getCode(), -1);
8132    }
8133  }
8134
8135  protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) {
8136    if (element == null) 
8137      return;
8138    Complex t;
8139    if (Utilities.noString(parentType))
8140      t = parent;
8141    else {
8142      t = parent.predicate("fhir:"+parentType+'.'+name);
8143    }
8144    composeDomainResource(t, "DetectedIssue", name, element, index);
8145    for (int i = 0; i < element.getIdentifier().size(); i++) {
8146      composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier().get(i), i);
8147    }
8148    if (element.hasStatusElement()) {
8149      composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1);
8150    }
8151    if (element.hasCode()) {
8152      composeCodeableConcept(t, "DetectedIssue", "code", element.getCode(), -1);
8153    }
8154    if (element.hasSeverityElement()) {
8155      composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1);
8156    }
8157    if (element.hasPatient()) {
8158      composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1);
8159    }
8160    if (element.hasIdentified()) {
8161      composeType(t, "DetectedIssue", "identified", element.getIdentified(), -1);
8162    }
8163    if (element.hasAuthor()) {
8164      composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1);
8165    }
8166    for (int i = 0; i < element.getImplicated().size(); i++) {
8167      composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i);
8168    }
8169    for (int i = 0; i < element.getEvidence().size(); i++) {
8170      composeDetectedIssueEvidenceComponent(t, "DetectedIssue", "evidence", element.getEvidence().get(i), i);
8171    }
8172    if (element.hasDetailElement()) {
8173      composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1);
8174    }
8175    if (element.hasReferenceElement()) {
8176      composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1);
8177    }
8178    for (int i = 0; i < element.getMitigation().size(); i++) {
8179      composeDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i);
8180    }
8181  }
8182
8183  protected void composeDetectedIssueEvidenceComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueEvidenceComponent element, int index) {
8184    if (element == null) 
8185      return;
8186    Complex t;
8187    if (Utilities.noString(parentType))
8188      t = parent;
8189    else {
8190      t = parent.predicate("fhir:"+parentType+'.'+name);
8191    }
8192    composeBackboneElement(t, "evidence", name, element, index);
8193    for (int i = 0; i < element.getCode().size(); i++) {
8194      composeCodeableConcept(t, "DetectedIssueEvidenceComponent", "code", element.getCode().get(i), i);
8195    }
8196    for (int i = 0; i < element.getDetail().size(); i++) {
8197      composeReference(t, "DetectedIssueEvidenceComponent", "detail", element.getDetail().get(i), i);
8198    }
8199  }
8200
8201  protected void composeDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) {
8202    if (element == null) 
8203      return;
8204    Complex t;
8205    if (Utilities.noString(parentType))
8206      t = parent;
8207    else {
8208      t = parent.predicate("fhir:"+parentType+'.'+name);
8209    }
8210    composeBackboneElement(t, "mitigation", name, element, index);
8211    if (element.hasAction()) {
8212      composeCodeableConcept(t, "DetectedIssueMitigationComponent", "action", element.getAction(), -1);
8213    }
8214    if (element.hasDateElement()) {
8215      composeDateTime(t, "DetectedIssueMitigationComponent", "date", element.getDateElement(), -1);
8216    }
8217    if (element.hasAuthor()) {
8218      composeReference(t, "DetectedIssueMitigationComponent", "author", element.getAuthor(), -1);
8219    }
8220  }
8221
8222  protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) {
8223    if (element == null) 
8224      return;
8225    Complex t;
8226    if (Utilities.noString(parentType))
8227      t = parent;
8228    else {
8229      t = parent.predicate("fhir:"+parentType+'.'+name);
8230    }
8231    composeDomainResource(t, "Device", name, element, index);
8232    for (int i = 0; i < element.getIdentifier().size(); i++) {
8233      composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i);
8234    }
8235    if (element.hasDefinition()) {
8236      composeReference(t, "Device", "definition", element.getDefinition(), -1);
8237    }
8238    for (int i = 0; i < element.getUdiCarrier().size(); i++) {
8239      composeDeviceUdiCarrierComponent(t, "Device", "udiCarrier", element.getUdiCarrier().get(i), i);
8240    }
8241    if (element.hasStatusElement()) {
8242      composeEnum(t, "Device", "status", element.getStatusElement(), -1);
8243    }
8244    for (int i = 0; i < element.getStatusReason().size(); i++) {
8245      composeCodeableConcept(t, "Device", "statusReason", element.getStatusReason().get(i), i);
8246    }
8247    if (element.hasDistinctIdentifierElement()) {
8248      composeString(t, "Device", "distinctIdentifier", element.getDistinctIdentifierElement(), -1);
8249    }
8250    if (element.hasManufacturerElement()) {
8251      composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1);
8252    }
8253    if (element.hasManufactureDateElement()) {
8254      composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1);
8255    }
8256    if (element.hasExpirationDateElement()) {
8257      composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1);
8258    }
8259    if (element.hasLotNumberElement()) {
8260      composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1);
8261    }
8262    if (element.hasSerialNumberElement()) {
8263      composeString(t, "Device", "serialNumber", element.getSerialNumberElement(), -1);
8264    }
8265    for (int i = 0; i < element.getDeviceName().size(); i++) {
8266      composeDeviceDeviceNameComponent(t, "Device", "deviceName", element.getDeviceName().get(i), i);
8267    }
8268    if (element.hasModelNumberElement()) {
8269      composeString(t, "Device", "modelNumber", element.getModelNumberElement(), -1);
8270    }
8271    if (element.hasPartNumberElement()) {
8272      composeString(t, "Device", "partNumber", element.getPartNumberElement(), -1);
8273    }
8274    if (element.hasType()) {
8275      composeCodeableConcept(t, "Device", "type", element.getType(), -1);
8276    }
8277    for (int i = 0; i < element.getSpecialization().size(); i++) {
8278      composeDeviceSpecializationComponent(t, "Device", "specialization", element.getSpecialization().get(i), i);
8279    }
8280    for (int i = 0; i < element.getVersion().size(); i++) {
8281      composeDeviceVersionComponent(t, "Device", "version", element.getVersion().get(i), i);
8282    }
8283    for (int i = 0; i < element.getProperty().size(); i++) {
8284      composeDevicePropertyComponent(t, "Device", "property", element.getProperty().get(i), i);
8285    }
8286    if (element.hasPatient()) {
8287      composeReference(t, "Device", "patient", element.getPatient(), -1);
8288    }
8289    if (element.hasOwner()) {
8290      composeReference(t, "Device", "owner", element.getOwner(), -1);
8291    }
8292    for (int i = 0; i < element.getContact().size(); i++) {
8293      composeContactPoint(t, "Device", "contact", element.getContact().get(i), i);
8294    }
8295    if (element.hasLocation()) {
8296      composeReference(t, "Device", "location", element.getLocation(), -1);
8297    }
8298    if (element.hasUrlElement()) {
8299      composeUri(t, "Device", "url", element.getUrlElement(), -1);
8300    }
8301    for (int i = 0; i < element.getNote().size(); i++) {
8302      composeAnnotation(t, "Device", "note", element.getNote().get(i), i);
8303    }
8304    for (int i = 0; i < element.getSafety().size(); i++) {
8305      composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i);
8306    }
8307    if (element.hasParent()) {
8308      composeReference(t, "Device", "parent", element.getParent(), -1);
8309    }
8310  }
8311
8312  protected void composeDeviceUdiCarrierComponent(Complex parent, String parentType, String name, Device.DeviceUdiCarrierComponent element, int index) {
8313    if (element == null) 
8314      return;
8315    Complex t;
8316    if (Utilities.noString(parentType))
8317      t = parent;
8318    else {
8319      t = parent.predicate("fhir:"+parentType+'.'+name);
8320    }
8321    composeBackboneElement(t, "udiCarrier", name, element, index);
8322    if (element.hasDeviceIdentifierElement()) {
8323      composeString(t, "DeviceUdiCarrierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
8324    }
8325    if (element.hasIssuerElement()) {
8326      composeUri(t, "DeviceUdiCarrierComponent", "issuer", element.getIssuerElement(), -1);
8327    }
8328    if (element.hasJurisdictionElement()) {
8329      composeUri(t, "DeviceUdiCarrierComponent", "jurisdiction", element.getJurisdictionElement(), -1);
8330    }
8331    if (element.hasCarrierAIDCElement()) {
8332      composeBase64Binary(t, "DeviceUdiCarrierComponent", "carrierAIDC", element.getCarrierAIDCElement(), -1);
8333    }
8334    if (element.hasCarrierHRFElement()) {
8335      composeString(t, "DeviceUdiCarrierComponent", "carrierHRF", element.getCarrierHRFElement(), -1);
8336    }
8337    if (element.hasEntryTypeElement()) {
8338      composeEnum(t, "DeviceUdiCarrierComponent", "entryType", element.getEntryTypeElement(), -1);
8339    }
8340  }
8341
8342  protected void composeDeviceDeviceNameComponent(Complex parent, String parentType, String name, Device.DeviceDeviceNameComponent element, int index) {
8343    if (element == null) 
8344      return;
8345    Complex t;
8346    if (Utilities.noString(parentType))
8347      t = parent;
8348    else {
8349      t = parent.predicate("fhir:"+parentType+'.'+name);
8350    }
8351    composeBackboneElement(t, "deviceName", name, element, index);
8352    if (element.hasNameElement()) {
8353      composeString(t, "DeviceDeviceNameComponent", "name", element.getNameElement(), -1);
8354    }
8355    if (element.hasTypeElement()) {
8356      composeEnum(t, "DeviceDeviceNameComponent", "type", element.getTypeElement(), -1);
8357    }
8358  }
8359
8360  protected void composeDeviceSpecializationComponent(Complex parent, String parentType, String name, Device.DeviceSpecializationComponent element, int index) {
8361    if (element == null) 
8362      return;
8363    Complex t;
8364    if (Utilities.noString(parentType))
8365      t = parent;
8366    else {
8367      t = parent.predicate("fhir:"+parentType+'.'+name);
8368    }
8369    composeBackboneElement(t, "specialization", name, element, index);
8370    if (element.hasSystemType()) {
8371      composeCodeableConcept(t, "DeviceSpecializationComponent", "systemType", element.getSystemType(), -1);
8372    }
8373    if (element.hasVersionElement()) {
8374      composeString(t, "DeviceSpecializationComponent", "version", element.getVersionElement(), -1);
8375    }
8376  }
8377
8378  protected void composeDeviceVersionComponent(Complex parent, String parentType, String name, Device.DeviceVersionComponent element, int index) {
8379    if (element == null) 
8380      return;
8381    Complex t;
8382    if (Utilities.noString(parentType))
8383      t = parent;
8384    else {
8385      t = parent.predicate("fhir:"+parentType+'.'+name);
8386    }
8387    composeBackboneElement(t, "version", name, element, index);
8388    if (element.hasType()) {
8389      composeCodeableConcept(t, "DeviceVersionComponent", "type", element.getType(), -1);
8390    }
8391    if (element.hasComponent()) {
8392      composeIdentifier(t, "DeviceVersionComponent", "component", element.getComponent(), -1);
8393    }
8394    if (element.hasValueElement()) {
8395      composeString(t, "DeviceVersionComponent", "value", element.getValueElement(), -1);
8396    }
8397  }
8398
8399  protected void composeDevicePropertyComponent(Complex parent, String parentType, String name, Device.DevicePropertyComponent element, int index) {
8400    if (element == null) 
8401      return;
8402    Complex t;
8403    if (Utilities.noString(parentType))
8404      t = parent;
8405    else {
8406      t = parent.predicate("fhir:"+parentType+'.'+name);
8407    }
8408    composeBackboneElement(t, "property", name, element, index);
8409    if (element.hasType()) {
8410      composeCodeableConcept(t, "DevicePropertyComponent", "type", element.getType(), -1);
8411    }
8412    for (int i = 0; i < element.getValueQuantity().size(); i++) {
8413      composeQuantity(t, "DevicePropertyComponent", "valueQuantity", element.getValueQuantity().get(i), i);
8414    }
8415    for (int i = 0; i < element.getValueCode().size(); i++) {
8416      composeCodeableConcept(t, "DevicePropertyComponent", "valueCode", element.getValueCode().get(i), i);
8417    }
8418  }
8419
8420  protected void composeDeviceDefinition(Complex parent, String parentType, String name, DeviceDefinition element, int index) {
8421    if (element == null) 
8422      return;
8423    Complex t;
8424    if (Utilities.noString(parentType))
8425      t = parent;
8426    else {
8427      t = parent.predicate("fhir:"+parentType+'.'+name);
8428    }
8429    composeDomainResource(t, "DeviceDefinition", name, element, index);
8430    for (int i = 0; i < element.getIdentifier().size(); i++) {
8431      composeIdentifier(t, "DeviceDefinition", "identifier", element.getIdentifier().get(i), i);
8432    }
8433    for (int i = 0; i < element.getUdiDeviceIdentifier().size(); i++) {
8434      composeDeviceDefinitionUdiDeviceIdentifierComponent(t, "DeviceDefinition", "udiDeviceIdentifier", element.getUdiDeviceIdentifier().get(i), i);
8435    }
8436    if (element.hasManufacturer()) {
8437      composeType(t, "DeviceDefinition", "manufacturer", element.getManufacturer(), -1);
8438    }
8439    for (int i = 0; i < element.getDeviceName().size(); i++) {
8440      composeDeviceDefinitionDeviceNameComponent(t, "DeviceDefinition", "deviceName", element.getDeviceName().get(i), i);
8441    }
8442    if (element.hasModelNumberElement()) {
8443      composeString(t, "DeviceDefinition", "modelNumber", element.getModelNumberElement(), -1);
8444    }
8445    if (element.hasType()) {
8446      composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1);
8447    }
8448    for (int i = 0; i < element.getSpecialization().size(); i++) {
8449      composeDeviceDefinitionSpecializationComponent(t, "DeviceDefinition", "specialization", element.getSpecialization().get(i), i);
8450    }
8451    for (int i = 0; i < element.getVersion().size(); i++) {
8452      composeString(t, "DeviceDefinition", "version", element.getVersion().get(i), i);
8453    }
8454    for (int i = 0; i < element.getSafety().size(); i++) {
8455      composeCodeableConcept(t, "DeviceDefinition", "safety", element.getSafety().get(i), i);
8456    }
8457    for (int i = 0; i < element.getShelfLifeStorage().size(); i++) {
8458      composeProductShelfLife(t, "DeviceDefinition", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i);
8459    }
8460    if (element.hasPhysicalCharacteristics()) {
8461      composeProdCharacteristic(t, "DeviceDefinition", "physicalCharacteristics", element.getPhysicalCharacteristics(), -1);
8462    }
8463    for (int i = 0; i < element.getLanguageCode().size(); i++) {
8464      composeCodeableConcept(t, "DeviceDefinition", "languageCode", element.getLanguageCode().get(i), i);
8465    }
8466    for (int i = 0; i < element.getCapability().size(); i++) {
8467      composeDeviceDefinitionCapabilityComponent(t, "DeviceDefinition", "capability", element.getCapability().get(i), i);
8468    }
8469    for (int i = 0; i < element.getProperty().size(); i++) {
8470      composeDeviceDefinitionPropertyComponent(t, "DeviceDefinition", "property", element.getProperty().get(i), i);
8471    }
8472    if (element.hasOwner()) {
8473      composeReference(t, "DeviceDefinition", "owner", element.getOwner(), -1);
8474    }
8475    for (int i = 0; i < element.getContact().size(); i++) {
8476      composeContactPoint(t, "DeviceDefinition", "contact", element.getContact().get(i), i);
8477    }
8478    if (element.hasUrlElement()) {
8479      composeUri(t, "DeviceDefinition", "url", element.getUrlElement(), -1);
8480    }
8481    if (element.hasOnlineInformationElement()) {
8482      composeUri(t, "DeviceDefinition", "onlineInformation", element.getOnlineInformationElement(), -1);
8483    }
8484    for (int i = 0; i < element.getNote().size(); i++) {
8485      composeAnnotation(t, "DeviceDefinition", "note", element.getNote().get(i), i);
8486    }
8487    if (element.hasQuantity()) {
8488      composeQuantity(t, "DeviceDefinition", "quantity", element.getQuantity(), -1);
8489    }
8490    if (element.hasParentDevice()) {
8491      composeReference(t, "DeviceDefinition", "parentDevice", element.getParentDevice(), -1);
8492    }
8493    for (int i = 0; i < element.getMaterial().size(); i++) {
8494      composeDeviceDefinitionMaterialComponent(t, "DeviceDefinition", "material", element.getMaterial().get(i), i);
8495    }
8496  }
8497
8498  protected void composeDeviceDefinitionUdiDeviceIdentifierComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionUdiDeviceIdentifierComponent element, int index) {
8499    if (element == null) 
8500      return;
8501    Complex t;
8502    if (Utilities.noString(parentType))
8503      t = parent;
8504    else {
8505      t = parent.predicate("fhir:"+parentType+'.'+name);
8506    }
8507    composeBackboneElement(t, "udiDeviceIdentifier", name, element, index);
8508    if (element.hasDeviceIdentifierElement()) {
8509      composeString(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1);
8510    }
8511    if (element.hasIssuerElement()) {
8512      composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "issuer", element.getIssuerElement(), -1);
8513    }
8514    if (element.hasJurisdictionElement()) {
8515      composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "jurisdiction", element.getJurisdictionElement(), -1);
8516    }
8517  }
8518
8519  protected void composeDeviceDefinitionDeviceNameComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionDeviceNameComponent element, int index) {
8520    if (element == null) 
8521      return;
8522    Complex t;
8523    if (Utilities.noString(parentType))
8524      t = parent;
8525    else {
8526      t = parent.predicate("fhir:"+parentType+'.'+name);
8527    }
8528    composeBackboneElement(t, "deviceName", name, element, index);
8529    if (element.hasNameElement()) {
8530      composeString(t, "DeviceDefinitionDeviceNameComponent", "name", element.getNameElement(), -1);
8531    }
8532    if (element.hasTypeElement()) {
8533      composeEnum(t, "DeviceDefinitionDeviceNameComponent", "type", element.getTypeElement(), -1);
8534    }
8535  }
8536
8537  protected void composeDeviceDefinitionSpecializationComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionSpecializationComponent element, int index) {
8538    if (element == null) 
8539      return;
8540    Complex t;
8541    if (Utilities.noString(parentType))
8542      t = parent;
8543    else {
8544      t = parent.predicate("fhir:"+parentType+'.'+name);
8545    }
8546    composeBackboneElement(t, "specialization", name, element, index);
8547    if (element.hasSystemTypeElement()) {
8548      composeString(t, "DeviceDefinitionSpecializationComponent", "systemType", element.getSystemTypeElement(), -1);
8549    }
8550    if (element.hasVersionElement()) {
8551      composeString(t, "DeviceDefinitionSpecializationComponent", "version", element.getVersionElement(), -1);
8552    }
8553  }
8554
8555  protected void composeDeviceDefinitionCapabilityComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionCapabilityComponent 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    composeBackboneElement(t, "capability", name, element, index);
8565    if (element.hasType()) {
8566      composeCodeableConcept(t, "DeviceDefinitionCapabilityComponent", "type", element.getType(), -1);
8567    }
8568    for (int i = 0; i < element.getDescription().size(); i++) {
8569      composeCodeableConcept(t, "DeviceDefinitionCapabilityComponent", "description", element.getDescription().get(i), i);
8570    }
8571  }
8572
8573  protected void composeDeviceDefinitionPropertyComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionPropertyComponent element, int index) {
8574    if (element == null) 
8575      return;
8576    Complex t;
8577    if (Utilities.noString(parentType))
8578      t = parent;
8579    else {
8580      t = parent.predicate("fhir:"+parentType+'.'+name);
8581    }
8582    composeBackboneElement(t, "property", name, element, index);
8583    if (element.hasType()) {
8584      composeCodeableConcept(t, "DeviceDefinitionPropertyComponent", "type", element.getType(), -1);
8585    }
8586    for (int i = 0; i < element.getValueQuantity().size(); i++) {
8587      composeQuantity(t, "DeviceDefinitionPropertyComponent", "valueQuantity", element.getValueQuantity().get(i), i);
8588    }
8589    for (int i = 0; i < element.getValueCode().size(); i++) {
8590      composeCodeableConcept(t, "DeviceDefinitionPropertyComponent", "valueCode", element.getValueCode().get(i), i);
8591    }
8592  }
8593
8594  protected void composeDeviceDefinitionMaterialComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionMaterialComponent element, int index) {
8595    if (element == null) 
8596      return;
8597    Complex t;
8598    if (Utilities.noString(parentType))
8599      t = parent;
8600    else {
8601      t = parent.predicate("fhir:"+parentType+'.'+name);
8602    }
8603    composeBackboneElement(t, "material", name, element, index);
8604    if (element.hasSubstance()) {
8605      composeCodeableConcept(t, "DeviceDefinitionMaterialComponent", "substance", element.getSubstance(), -1);
8606    }
8607    if (element.hasAlternateElement()) {
8608      composeBoolean(t, "DeviceDefinitionMaterialComponent", "alternate", element.getAlternateElement(), -1);
8609    }
8610    if (element.hasAllergenicIndicatorElement()) {
8611      composeBoolean(t, "DeviceDefinitionMaterialComponent", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1);
8612    }
8613  }
8614
8615  protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) {
8616    if (element == null) 
8617      return;
8618    Complex t;
8619    if (Utilities.noString(parentType))
8620      t = parent;
8621    else {
8622      t = parent.predicate("fhir:"+parentType+'.'+name);
8623    }
8624    composeDomainResource(t, "DeviceMetric", name, element, index);
8625    for (int i = 0; i < element.getIdentifier().size(); i++) {
8626      composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier().get(i), i);
8627    }
8628    if (element.hasType()) {
8629      composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1);
8630    }
8631    if (element.hasUnit()) {
8632      composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1);
8633    }
8634    if (element.hasSource()) {
8635      composeReference(t, "DeviceMetric", "source", element.getSource(), -1);
8636    }
8637    if (element.hasParent()) {
8638      composeReference(t, "DeviceMetric", "parent", element.getParent(), -1);
8639    }
8640    if (element.hasOperationalStatusElement()) {
8641      composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1);
8642    }
8643    if (element.hasColorElement()) {
8644      composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1);
8645    }
8646    if (element.hasCategoryElement()) {
8647      composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1);
8648    }
8649    if (element.hasMeasurementPeriod()) {
8650      composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1);
8651    }
8652    for (int i = 0; i < element.getCalibration().size(); i++) {
8653      composeDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i);
8654    }
8655  }
8656
8657  protected void composeDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent 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    composeBackboneElement(t, "calibration", name, element, index);
8667    if (element.hasTypeElement()) {
8668      composeEnum(t, "DeviceMetricCalibrationComponent", "type", element.getTypeElement(), -1);
8669    }
8670    if (element.hasStateElement()) {
8671      composeEnum(t, "DeviceMetricCalibrationComponent", "state", element.getStateElement(), -1);
8672    }
8673    if (element.hasTimeElement()) {
8674      composeInstant(t, "DeviceMetricCalibrationComponent", "time", element.getTimeElement(), -1);
8675    }
8676  }
8677
8678  protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) {
8679    if (element == null) 
8680      return;
8681    Complex t;
8682    if (Utilities.noString(parentType))
8683      t = parent;
8684    else {
8685      t = parent.predicate("fhir:"+parentType+'.'+name);
8686    }
8687    composeDomainResource(t, "DeviceRequest", name, element, index);
8688    for (int i = 0; i < element.getIdentifier().size(); i++) {
8689      composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i);
8690    }
8691    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
8692      composeCanonical(t, "DeviceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
8693    }
8694    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
8695      composeUri(t, "DeviceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
8696    }
8697    for (int i = 0; i < element.getBasedOn().size(); i++) {
8698      composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i);
8699    }
8700    for (int i = 0; i < element.getPriorRequest().size(); i++) {
8701      composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i);
8702    }
8703    if (element.hasGroupIdentifier()) {
8704      composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
8705    }
8706    if (element.hasStatusElement()) {
8707      composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1);
8708    }
8709    if (element.hasIntentElement()) {
8710      composeEnum(t, "DeviceRequest", "intent", element.getIntentElement(), -1);
8711    }
8712    if (element.hasPriorityElement()) {
8713      composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1);
8714    }
8715    if (element.hasCode()) {
8716      composeType(t, "DeviceRequest", "code", element.getCode(), -1);
8717    }
8718    for (int i = 0; i < element.getParameter().size(); i++) {
8719      composeDeviceRequestParameterComponent(t, "DeviceRequest", "parameter", element.getParameter().get(i), i);
8720    }
8721    if (element.hasSubject()) {
8722      composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1);
8723    }
8724    if (element.hasEncounter()) {
8725      composeReference(t, "DeviceRequest", "encounter", element.getEncounter(), -1);
8726    }
8727    if (element.hasOccurrence()) {
8728      composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1);
8729    }
8730    if (element.hasAuthoredOnElement()) {
8731      composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
8732    }
8733    if (element.hasRequester()) {
8734      composeReference(t, "DeviceRequest", "requester", element.getRequester(), -1);
8735    }
8736    if (element.hasPerformerType()) {
8737      composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1);
8738    }
8739    if (element.hasPerformer()) {
8740      composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1);
8741    }
8742    for (int i = 0; i < element.getReason().size(); i++) {
8743      composeCodeableReference(t, "DeviceRequest", "reason", element.getReason().get(i), i);
8744    }
8745    for (int i = 0; i < element.getInsurance().size(); i++) {
8746      composeReference(t, "DeviceRequest", "insurance", element.getInsurance().get(i), i);
8747    }
8748    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
8749      composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
8750    }
8751    for (int i = 0; i < element.getNote().size(); i++) {
8752      composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i);
8753    }
8754    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
8755      composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
8756    }
8757  }
8758
8759  protected void composeDeviceRequestParameterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestParameterComponent element, int index) {
8760    if (element == null) 
8761      return;
8762    Complex t;
8763    if (Utilities.noString(parentType))
8764      t = parent;
8765    else {
8766      t = parent.predicate("fhir:"+parentType+'.'+name);
8767    }
8768    composeBackboneElement(t, "parameter", name, element, index);
8769    if (element.hasCode()) {
8770      composeCodeableConcept(t, "DeviceRequestParameterComponent", "code", element.getCode(), -1);
8771    }
8772    if (element.hasValue()) {
8773      composeType(t, "DeviceRequestParameterComponent", "value", element.getValue(), -1);
8774    }
8775  }
8776
8777  protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) {
8778    if (element == null) 
8779      return;
8780    Complex t;
8781    if (Utilities.noString(parentType))
8782      t = parent;
8783    else {
8784      t = parent.predicate("fhir:"+parentType+'.'+name);
8785    }
8786    composeDomainResource(t, "DeviceUseStatement", name, element, index);
8787    for (int i = 0; i < element.getIdentifier().size(); i++) {
8788      composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i);
8789    }
8790    for (int i = 0; i < element.getBasedOn().size(); i++) {
8791      composeReference(t, "DeviceUseStatement", "basedOn", element.getBasedOn().get(i), i);
8792    }
8793    if (element.hasStatusElement()) {
8794      composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1);
8795    }
8796    if (element.hasSubject()) {
8797      composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1);
8798    }
8799    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
8800      composeReference(t, "DeviceUseStatement", "derivedFrom", element.getDerivedFrom().get(i), i);
8801    }
8802    if (element.hasTiming()) {
8803      composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1);
8804    }
8805    if (element.hasRecordedOnElement()) {
8806      composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1);
8807    }
8808    if (element.hasSource()) {
8809      composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1);
8810    }
8811    if (element.hasDevice()) {
8812      composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1);
8813    }
8814    for (int i = 0; i < element.getReason().size(); i++) {
8815      composeCodeableReference(t, "DeviceUseStatement", "reason", element.getReason().get(i), i);
8816    }
8817    if (element.hasBodySite()) {
8818      composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1);
8819    }
8820    for (int i = 0; i < element.getNote().size(); i++) {
8821      composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i);
8822    }
8823  }
8824
8825  protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) {
8826    if (element == null) 
8827      return;
8828    Complex t;
8829    if (Utilities.noString(parentType))
8830      t = parent;
8831    else {
8832      t = parent.predicate("fhir:"+parentType+'.'+name);
8833    }
8834    composeDomainResource(t, "DiagnosticReport", name, element, index);
8835    for (int i = 0; i < element.getIdentifier().size(); i++) {
8836      composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i);
8837    }
8838    for (int i = 0; i < element.getBasedOn().size(); i++) {
8839      composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i);
8840    }
8841    if (element.hasStatusElement()) {
8842      composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1);
8843    }
8844    for (int i = 0; i < element.getCategory().size(); i++) {
8845      composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory().get(i), i);
8846    }
8847    if (element.hasCode()) {
8848      composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1);
8849    }
8850    if (element.hasSubject()) {
8851      composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1);
8852    }
8853    if (element.hasEncounter()) {
8854      composeReference(t, "DiagnosticReport", "encounter", element.getEncounter(), -1);
8855    }
8856    if (element.hasEffective()) {
8857      composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1);
8858    }
8859    if (element.hasIssuedElement()) {
8860      composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1);
8861    }
8862    for (int i = 0; i < element.getPerformer().size(); i++) {
8863      composeReference(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i);
8864    }
8865    for (int i = 0; i < element.getResultsInterpreter().size(); i++) {
8866      composeReference(t, "DiagnosticReport", "resultsInterpreter", element.getResultsInterpreter().get(i), i);
8867    }
8868    for (int i = 0; i < element.getSpecimen().size(); i++) {
8869      composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i);
8870    }
8871    for (int i = 0; i < element.getResult().size(); i++) {
8872      composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i);
8873    }
8874    for (int i = 0; i < element.getImagingStudy().size(); i++) {
8875      composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i);
8876    }
8877    for (int i = 0; i < element.getMedia().size(); i++) {
8878      composeDiagnosticReportMediaComponent(t, "DiagnosticReport", "media", element.getMedia().get(i), i);
8879    }
8880    if (element.hasConclusionElement()) {
8881      composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1);
8882    }
8883    for (int i = 0; i < element.getConclusionCode().size(); i++) {
8884      composeCodeableConcept(t, "DiagnosticReport", "conclusionCode", element.getConclusionCode().get(i), i);
8885    }
8886    for (int i = 0; i < element.getPresentedForm().size(); i++) {
8887      composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i);
8888    }
8889  }
8890
8891  protected void composeDiagnosticReportMediaComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportMediaComponent element, int index) {
8892    if (element == null) 
8893      return;
8894    Complex t;
8895    if (Utilities.noString(parentType))
8896      t = parent;
8897    else {
8898      t = parent.predicate("fhir:"+parentType+'.'+name);
8899    }
8900    composeBackboneElement(t, "media", name, element, index);
8901    if (element.hasCommentElement()) {
8902      composeString(t, "DiagnosticReportMediaComponent", "comment", element.getCommentElement(), -1);
8903    }
8904    if (element.hasLink()) {
8905      composeReference(t, "DiagnosticReportMediaComponent", "link", element.getLink(), -1);
8906    }
8907  }
8908
8909  protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) {
8910    if (element == null) 
8911      return;
8912    Complex t;
8913    if (Utilities.noString(parentType))
8914      t = parent;
8915    else {
8916      t = parent.predicate("fhir:"+parentType+'.'+name);
8917    }
8918    composeDomainResource(t, "DocumentManifest", name, element, index);
8919    if (element.hasMasterIdentifier()) {
8920      composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1);
8921    }
8922    for (int i = 0; i < element.getIdentifier().size(); i++) {
8923      composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i);
8924    }
8925    if (element.hasStatusElement()) {
8926      composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1);
8927    }
8928    if (element.hasType()) {
8929      composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1);
8930    }
8931    if (element.hasSubject()) {
8932      composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1);
8933    }
8934    if (element.hasCreatedElement()) {
8935      composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1);
8936    }
8937    for (int i = 0; i < element.getAuthor().size(); i++) {
8938      composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i);
8939    }
8940    for (int i = 0; i < element.getRecipient().size(); i++) {
8941      composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i);
8942    }
8943    if (element.hasSourceElement()) {
8944      composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1);
8945    }
8946    if (element.hasDescriptionElement()) {
8947      composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1);
8948    }
8949    for (int i = 0; i < element.getContent().size(); i++) {
8950      composeReference(t, "DocumentManifest", "content", element.getContent().get(i), i);
8951    }
8952    for (int i = 0; i < element.getRelated().size(); i++) {
8953      composeDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i);
8954    }
8955  }
8956
8957  protected void composeDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) {
8958    if (element == null) 
8959      return;
8960    Complex t;
8961    if (Utilities.noString(parentType))
8962      t = parent;
8963    else {
8964      t = parent.predicate("fhir:"+parentType+'.'+name);
8965    }
8966    composeBackboneElement(t, "related", name, element, index);
8967    if (element.hasIdentifier()) {
8968      composeIdentifier(t, "DocumentManifestRelatedComponent", "identifier", element.getIdentifier(), -1);
8969    }
8970    if (element.hasRef()) {
8971      composeReference(t, "DocumentManifestRelatedComponent", "ref", element.getRef(), -1);
8972    }
8973  }
8974
8975  protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) {
8976    if (element == null) 
8977      return;
8978    Complex t;
8979    if (Utilities.noString(parentType))
8980      t = parent;
8981    else {
8982      t = parent.predicate("fhir:"+parentType+'.'+name);
8983    }
8984    composeDomainResource(t, "DocumentReference", name, element, index);
8985    if (element.hasMasterIdentifier()) {
8986      composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1);
8987    }
8988    for (int i = 0; i < element.getIdentifier().size(); i++) {
8989      composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i);
8990    }
8991    if (element.hasStatusElement()) {
8992      composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1);
8993    }
8994    if (element.hasDocStatusElement()) {
8995      composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1);
8996    }
8997    if (element.hasType()) {
8998      composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1);
8999    }
9000    for (int i = 0; i < element.getCategory().size(); i++) {
9001      composeCodeableConcept(t, "DocumentReference", "category", element.getCategory().get(i), i);
9002    }
9003    if (element.hasSubject()) {
9004      composeReference(t, "DocumentReference", "subject", element.getSubject(), -1);
9005    }
9006    if (element.hasDateElement()) {
9007      composeInstant(t, "DocumentReference", "date", element.getDateElement(), -1);
9008    }
9009    for (int i = 0; i < element.getAuthor().size(); i++) {
9010      composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i);
9011    }
9012    if (element.hasAuthenticator()) {
9013      composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1);
9014    }
9015    if (element.hasCustodian()) {
9016      composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1);
9017    }
9018    for (int i = 0; i < element.getRelatesTo().size(); i++) {
9019      composeDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i);
9020    }
9021    if (element.hasDescriptionElement()) {
9022      composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1);
9023    }
9024    for (int i = 0; i < element.getSecurityLabel().size(); i++) {
9025      composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i);
9026    }
9027    for (int i = 0; i < element.getContent().size(); i++) {
9028      composeDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i);
9029    }
9030    if (element.hasContext()) {
9031      composeDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1);
9032    }
9033  }
9034
9035  protected void composeDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) {
9036    if (element == null) 
9037      return;
9038    Complex t;
9039    if (Utilities.noString(parentType))
9040      t = parent;
9041    else {
9042      t = parent.predicate("fhir:"+parentType+'.'+name);
9043    }
9044    composeBackboneElement(t, "relatesTo", name, element, index);
9045    if (element.hasCodeElement()) {
9046      composeEnum(t, "DocumentReferenceRelatesToComponent", "code", element.getCodeElement(), -1);
9047    }
9048    if (element.hasTarget()) {
9049      composeReference(t, "DocumentReferenceRelatesToComponent", "target", element.getTarget(), -1);
9050    }
9051  }
9052
9053  protected void composeDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) {
9054    if (element == null) 
9055      return;
9056    Complex t;
9057    if (Utilities.noString(parentType))
9058      t = parent;
9059    else {
9060      t = parent.predicate("fhir:"+parentType+'.'+name);
9061    }
9062    composeBackboneElement(t, "content", name, element, index);
9063    if (element.hasAttachment()) {
9064      composeAttachment(t, "DocumentReferenceContentComponent", "attachment", element.getAttachment(), -1);
9065    }
9066    if (element.hasFormat()) {
9067      composeCoding(t, "DocumentReferenceContentComponent", "format", element.getFormat(), -1);
9068    }
9069  }
9070
9071  protected void composeDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) {
9072    if (element == null) 
9073      return;
9074    Complex t;
9075    if (Utilities.noString(parentType))
9076      t = parent;
9077    else {
9078      t = parent.predicate("fhir:"+parentType+'.'+name);
9079    }
9080    composeBackboneElement(t, "context", name, element, index);
9081    for (int i = 0; i < element.getEncounter().size(); i++) {
9082      composeReference(t, "DocumentReferenceContextComponent", "encounter", element.getEncounter().get(i), i);
9083    }
9084    for (int i = 0; i < element.getEvent().size(); i++) {
9085      composeCodeableConcept(t, "DocumentReferenceContextComponent", "event", element.getEvent().get(i), i);
9086    }
9087    if (element.hasPeriod()) {
9088      composePeriod(t, "DocumentReferenceContextComponent", "period", element.getPeriod(), -1);
9089    }
9090    if (element.hasFacilityType()) {
9091      composeCodeableConcept(t, "DocumentReferenceContextComponent", "facilityType", element.getFacilityType(), -1);
9092    }
9093    if (element.hasPracticeSetting()) {
9094      composeCodeableConcept(t, "DocumentReferenceContextComponent", "practiceSetting", element.getPracticeSetting(), -1);
9095    }
9096    if (element.hasSourcePatientInfo()) {
9097      composeReference(t, "DocumentReferenceContextComponent", "sourcePatientInfo", element.getSourcePatientInfo(), -1);
9098    }
9099    for (int i = 0; i < element.getRelated().size(); i++) {
9100      composeReference(t, "DocumentReferenceContextComponent", "related", element.getRelated().get(i), i);
9101    }
9102    for (int i = 0; i < element.getBasedOn().size(); i++) {
9103      composeReference(t, "DocumentReferenceContextComponent", "basedOn", element.getBasedOn().get(i), i);
9104    }
9105  }
9106
9107  protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) {
9108    if (element == null) 
9109      return;
9110    Complex t;
9111    if (Utilities.noString(parentType))
9112      t = parent;
9113    else {
9114      t = parent.predicate("fhir:"+parentType+'.'+name);
9115    }
9116    composeDomainResource(t, "Encounter", name, element, index);
9117    for (int i = 0; i < element.getIdentifier().size(); i++) {
9118      composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i);
9119    }
9120    if (element.hasStatusElement()) {
9121      composeEnum(t, "Encounter", "status", element.getStatusElement(), -1);
9122    }
9123    for (int i = 0; i < element.getStatusHistory().size(); i++) {
9124      composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i);
9125    }
9126    if (element.hasClass_()) {
9127      composeCoding(t, "Encounter", "class", element.getClass_(), -1);
9128    }
9129    for (int i = 0; i < element.getClassHistory().size(); i++) {
9130      composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i);
9131    }
9132    for (int i = 0; i < element.getType().size(); i++) {
9133      composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i);
9134    }
9135    if (element.hasServiceType()) {
9136      composeCodeableConcept(t, "Encounter", "serviceType", element.getServiceType(), -1);
9137    }
9138    if (element.hasPriority()) {
9139      composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1);
9140    }
9141    if (element.hasSubject()) {
9142      composeReference(t, "Encounter", "subject", element.getSubject(), -1);
9143    }
9144    if (element.hasSubjectStatus()) {
9145      composeCodeableConcept(t, "Encounter", "subjectStatus", element.getSubjectStatus(), -1);
9146    }
9147    for (int i = 0; i < element.getEpisodeOfCare().size(); i++) {
9148      composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i);
9149    }
9150    for (int i = 0; i < element.getBasedOn().size(); i++) {
9151      composeReference(t, "Encounter", "basedOn", element.getBasedOn().get(i), i);
9152    }
9153    for (int i = 0; i < element.getParticipant().size(); i++) {
9154      composeEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i);
9155    }
9156    for (int i = 0; i < element.getAppointment().size(); i++) {
9157      composeReference(t, "Encounter", "appointment", element.getAppointment().get(i), i);
9158    }
9159    if (element.hasPeriod()) {
9160      composePeriod(t, "Encounter", "period", element.getPeriod(), -1);
9161    }
9162    if (element.hasLength()) {
9163      composeDuration(t, "Encounter", "length", element.getLength(), -1);
9164    }
9165    for (int i = 0; i < element.getReason().size(); i++) {
9166      composeCodeableReference(t, "Encounter", "reason", element.getReason().get(i), i);
9167    }
9168    for (int i = 0; i < element.getDiagnosis().size(); i++) {
9169      composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i);
9170    }
9171    for (int i = 0; i < element.getAccount().size(); i++) {
9172      composeReference(t, "Encounter", "account", element.getAccount().get(i), i);
9173    }
9174    if (element.hasHospitalization()) {
9175      composeEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1);
9176    }
9177    for (int i = 0; i < element.getLocation().size(); i++) {
9178      composeEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i);
9179    }
9180    if (element.hasServiceProvider()) {
9181      composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1);
9182    }
9183    if (element.hasPartOf()) {
9184      composeReference(t, "Encounter", "partOf", element.getPartOf(), -1);
9185    }
9186  }
9187
9188  protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) {
9189    if (element == null) 
9190      return;
9191    Complex t;
9192    if (Utilities.noString(parentType))
9193      t = parent;
9194    else {
9195      t = parent.predicate("fhir:"+parentType+'.'+name);
9196    }
9197    composeBackboneElement(t, "statusHistory", name, element, index);
9198    if (element.hasStatusElement()) {
9199      composeEnum(t, "StatusHistoryComponent", "status", element.getStatusElement(), -1);
9200    }
9201    if (element.hasPeriod()) {
9202      composePeriod(t, "StatusHistoryComponent", "period", element.getPeriod(), -1);
9203    }
9204  }
9205
9206  protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) {
9207    if (element == null) 
9208      return;
9209    Complex t;
9210    if (Utilities.noString(parentType))
9211      t = parent;
9212    else {
9213      t = parent.predicate("fhir:"+parentType+'.'+name);
9214    }
9215    composeBackboneElement(t, "classHistory", name, element, index);
9216    if (element.hasClass_()) {
9217      composeCoding(t, "ClassHistoryComponent", "class", element.getClass_(), -1);
9218    }
9219    if (element.hasPeriod()) {
9220      composePeriod(t, "ClassHistoryComponent", "period", element.getPeriod(), -1);
9221    }
9222  }
9223
9224  protected void composeEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) {
9225    if (element == null) 
9226      return;
9227    Complex t;
9228    if (Utilities.noString(parentType))
9229      t = parent;
9230    else {
9231      t = parent.predicate("fhir:"+parentType+'.'+name);
9232    }
9233    composeBackboneElement(t, "participant", name, element, index);
9234    for (int i = 0; i < element.getType().size(); i++) {
9235      composeCodeableConcept(t, "EncounterParticipantComponent", "type", element.getType().get(i), i);
9236    }
9237    if (element.hasPeriod()) {
9238      composePeriod(t, "EncounterParticipantComponent", "period", element.getPeriod(), -1);
9239    }
9240    if (element.hasIndividual()) {
9241      composeReference(t, "EncounterParticipantComponent", "individual", element.getIndividual(), -1);
9242    }
9243  }
9244
9245  protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) {
9246    if (element == null) 
9247      return;
9248    Complex t;
9249    if (Utilities.noString(parentType))
9250      t = parent;
9251    else {
9252      t = parent.predicate("fhir:"+parentType+'.'+name);
9253    }
9254    composeBackboneElement(t, "diagnosis", name, element, index);
9255    if (element.hasCondition()) {
9256      composeReference(t, "DiagnosisComponent", "condition", element.getCondition(), -1);
9257    }
9258    if (element.hasUse()) {
9259      composeCodeableConcept(t, "DiagnosisComponent", "use", element.getUse(), -1);
9260    }
9261    if (element.hasRankElement()) {
9262      composePositiveInt(t, "DiagnosisComponent", "rank", element.getRankElement(), -1);
9263    }
9264  }
9265
9266  protected void composeEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) {
9267    if (element == null) 
9268      return;
9269    Complex t;
9270    if (Utilities.noString(parentType))
9271      t = parent;
9272    else {
9273      t = parent.predicate("fhir:"+parentType+'.'+name);
9274    }
9275    composeBackboneElement(t, "hospitalization", name, element, index);
9276    if (element.hasPreAdmissionIdentifier()) {
9277      composeIdentifier(t, "EncounterHospitalizationComponent", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1);
9278    }
9279    if (element.hasOrigin()) {
9280      composeReference(t, "EncounterHospitalizationComponent", "origin", element.getOrigin(), -1);
9281    }
9282    if (element.hasAdmitSource()) {
9283      composeCodeableConcept(t, "EncounterHospitalizationComponent", "admitSource", element.getAdmitSource(), -1);
9284    }
9285    if (element.hasReAdmission()) {
9286      composeCodeableConcept(t, "EncounterHospitalizationComponent", "reAdmission", element.getReAdmission(), -1);
9287    }
9288    for (int i = 0; i < element.getDietPreference().size(); i++) {
9289      composeCodeableConcept(t, "EncounterHospitalizationComponent", "dietPreference", element.getDietPreference().get(i), i);
9290    }
9291    for (int i = 0; i < element.getSpecialCourtesy().size(); i++) {
9292      composeCodeableConcept(t, "EncounterHospitalizationComponent", "specialCourtesy", element.getSpecialCourtesy().get(i), i);
9293    }
9294    for (int i = 0; i < element.getSpecialArrangement().size(); i++) {
9295      composeCodeableConcept(t, "EncounterHospitalizationComponent", "specialArrangement", element.getSpecialArrangement().get(i), i);
9296    }
9297    if (element.hasDestination()) {
9298      composeReference(t, "EncounterHospitalizationComponent", "destination", element.getDestination(), -1);
9299    }
9300    if (element.hasDischargeDisposition()) {
9301      composeCodeableConcept(t, "EncounterHospitalizationComponent", "dischargeDisposition", element.getDischargeDisposition(), -1);
9302    }
9303  }
9304
9305  protected void composeEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) {
9306    if (element == null) 
9307      return;
9308    Complex t;
9309    if (Utilities.noString(parentType))
9310      t = parent;
9311    else {
9312      t = parent.predicate("fhir:"+parentType+'.'+name);
9313    }
9314    composeBackboneElement(t, "location", name, element, index);
9315    if (element.hasLocation()) {
9316      composeReference(t, "EncounterLocationComponent", "location", element.getLocation(), -1);
9317    }
9318    if (element.hasStatusElement()) {
9319      composeEnum(t, "EncounterLocationComponent", "status", element.getStatusElement(), -1);
9320    }
9321    if (element.hasPhysicalType()) {
9322      composeCodeableConcept(t, "EncounterLocationComponent", "physicalType", element.getPhysicalType(), -1);
9323    }
9324    if (element.hasPeriod()) {
9325      composePeriod(t, "EncounterLocationComponent", "period", element.getPeriod(), -1);
9326    }
9327  }
9328
9329  protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) {
9330    if (element == null) 
9331      return;
9332    Complex t;
9333    if (Utilities.noString(parentType))
9334      t = parent;
9335    else {
9336      t = parent.predicate("fhir:"+parentType+'.'+name);
9337    }
9338    composeDomainResource(t, "Endpoint", name, element, index);
9339    for (int i = 0; i < element.getIdentifier().size(); i++) {
9340      composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i);
9341    }
9342    if (element.hasStatusElement()) {
9343      composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1);
9344    }
9345    if (element.hasConnectionType()) {
9346      composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1);
9347    }
9348    if (element.hasNameElement()) {
9349      composeString(t, "Endpoint", "name", element.getNameElement(), -1);
9350    }
9351    if (element.hasManagingOrganization()) {
9352      composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1);
9353    }
9354    for (int i = 0; i < element.getContact().size(); i++) {
9355      composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i);
9356    }
9357    if (element.hasPeriod()) {
9358      composePeriod(t, "Endpoint", "period", element.getPeriod(), -1);
9359    }
9360    for (int i = 0; i < element.getPayloadType().size(); i++) {
9361      composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i);
9362    }
9363    for (int i = 0; i < element.getPayloadMimeType().size(); i++) {
9364      composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i);
9365    }
9366    if (element.hasAddressElement()) {
9367      composeUrl(t, "Endpoint", "address", element.getAddressElement(), -1);
9368    }
9369    for (int i = 0; i < element.getHeader().size(); i++) {
9370      composeString(t, "Endpoint", "header", element.getHeader().get(i), i);
9371    }
9372  }
9373
9374  protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) {
9375    if (element == null) 
9376      return;
9377    Complex t;
9378    if (Utilities.noString(parentType))
9379      t = parent;
9380    else {
9381      t = parent.predicate("fhir:"+parentType+'.'+name);
9382    }
9383    composeDomainResource(t, "EnrollmentRequest", name, element, index);
9384    for (int i = 0; i < element.getIdentifier().size(); i++) {
9385      composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i);
9386    }
9387    if (element.hasStatusElement()) {
9388      composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1);
9389    }
9390    if (element.hasCreatedElement()) {
9391      composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1);
9392    }
9393    if (element.hasInsurer()) {
9394      composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1);
9395    }
9396    if (element.hasProvider()) {
9397      composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1);
9398    }
9399    if (element.hasCandidate()) {
9400      composeReference(t, "EnrollmentRequest", "candidate", element.getCandidate(), -1);
9401    }
9402    if (element.hasCoverage()) {
9403      composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1);
9404    }
9405  }
9406
9407  protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) {
9408    if (element == null) 
9409      return;
9410    Complex t;
9411    if (Utilities.noString(parentType))
9412      t = parent;
9413    else {
9414      t = parent.predicate("fhir:"+parentType+'.'+name);
9415    }
9416    composeDomainResource(t, "EnrollmentResponse", name, element, index);
9417    for (int i = 0; i < element.getIdentifier().size(); i++) {
9418      composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i);
9419    }
9420    if (element.hasStatusElement()) {
9421      composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1);
9422    }
9423    if (element.hasRequest()) {
9424      composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1);
9425    }
9426    if (element.hasOutcomeElement()) {
9427      composeEnum(t, "EnrollmentResponse", "outcome", element.getOutcomeElement(), -1);
9428    }
9429    if (element.hasDispositionElement()) {
9430      composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1);
9431    }
9432    if (element.hasCreatedElement()) {
9433      composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1);
9434    }
9435    if (element.hasOrganization()) {
9436      composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1);
9437    }
9438    if (element.hasRequestProvider()) {
9439      composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1);
9440    }
9441  }
9442
9443  protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) {
9444    if (element == null) 
9445      return;
9446    Complex t;
9447    if (Utilities.noString(parentType))
9448      t = parent;
9449    else {
9450      t = parent.predicate("fhir:"+parentType+'.'+name);
9451    }
9452    composeDomainResource(t, "EpisodeOfCare", name, element, index);
9453    for (int i = 0; i < element.getIdentifier().size(); i++) {
9454      composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i);
9455    }
9456    if (element.hasStatusElement()) {
9457      composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1);
9458    }
9459    for (int i = 0; i < element.getStatusHistory().size(); i++) {
9460      composeEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i);
9461    }
9462    for (int i = 0; i < element.getType().size(); i++) {
9463      composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i);
9464    }
9465    for (int i = 0; i < element.getDiagnosis().size(); i++) {
9466      composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i);
9467    }
9468    if (element.hasPatient()) {
9469      composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1);
9470    }
9471    if (element.hasManagingOrganization()) {
9472      composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1);
9473    }
9474    if (element.hasPeriod()) {
9475      composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1);
9476    }
9477    for (int i = 0; i < element.getReferralRequest().size(); i++) {
9478      composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i);
9479    }
9480    if (element.hasCareManager()) {
9481      composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1);
9482    }
9483    for (int i = 0; i < element.getTeam().size(); i++) {
9484      composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i);
9485    }
9486    for (int i = 0; i < element.getAccount().size(); i++) {
9487      composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i);
9488    }
9489  }
9490
9491  protected void composeEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) {
9492    if (element == null) 
9493      return;
9494    Complex t;
9495    if (Utilities.noString(parentType))
9496      t = parent;
9497    else {
9498      t = parent.predicate("fhir:"+parentType+'.'+name);
9499    }
9500    composeBackboneElement(t, "statusHistory", name, element, index);
9501    if (element.hasStatusElement()) {
9502      composeEnum(t, "EpisodeOfCareStatusHistoryComponent", "status", element.getStatusElement(), -1);
9503    }
9504    if (element.hasPeriod()) {
9505      composePeriod(t, "EpisodeOfCareStatusHistoryComponent", "period", element.getPeriod(), -1);
9506    }
9507  }
9508
9509  protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) {
9510    if (element == null) 
9511      return;
9512    Complex t;
9513    if (Utilities.noString(parentType))
9514      t = parent;
9515    else {
9516      t = parent.predicate("fhir:"+parentType+'.'+name);
9517    }
9518    composeBackboneElement(t, "diagnosis", name, element, index);
9519    if (element.hasCondition()) {
9520      composeReference(t, "DiagnosisComponent", "condition", element.getCondition(), -1);
9521    }
9522    if (element.hasRole()) {
9523      composeCodeableConcept(t, "DiagnosisComponent", "role", element.getRole(), -1);
9524    }
9525    if (element.hasRankElement()) {
9526      composePositiveInt(t, "DiagnosisComponent", "rank", element.getRankElement(), -1);
9527    }
9528  }
9529
9530  protected void composeEventDefinition(Complex parent, String parentType, String name, EventDefinition element, int index) {
9531    if (element == null) 
9532      return;
9533    Complex t;
9534    if (Utilities.noString(parentType))
9535      t = parent;
9536    else {
9537      t = parent.predicate("fhir:"+parentType+'.'+name);
9538    }
9539    composeMetadataResource(t, "EventDefinition", name, element, index);
9540    if (element.hasUrlElement()) {
9541      composeUri(t, "EventDefinition", "url", element.getUrlElement(), -1);
9542    }
9543    for (int i = 0; i < element.getIdentifier().size(); i++) {
9544      composeIdentifier(t, "EventDefinition", "identifier", element.getIdentifier().get(i), i);
9545    }
9546    if (element.hasVersionElement()) {
9547      composeString(t, "EventDefinition", "version", element.getVersionElement(), -1);
9548    }
9549    if (element.hasNameElement()) {
9550      composeString(t, "EventDefinition", "name", element.getNameElement(), -1);
9551    }
9552    if (element.hasTitleElement()) {
9553      composeString(t, "EventDefinition", "title", element.getTitleElement(), -1);
9554    }
9555    if (element.hasSubtitleElement()) {
9556      composeString(t, "EventDefinition", "subtitle", element.getSubtitleElement(), -1);
9557    }
9558    if (element.hasStatusElement()) {
9559      composeEnum(t, "EventDefinition", "status", element.getStatusElement(), -1);
9560    }
9561    if (element.hasExperimentalElement()) {
9562      composeBoolean(t, "EventDefinition", "experimental", element.getExperimentalElement(), -1);
9563    }
9564    if (element.hasSubject()) {
9565      composeType(t, "EventDefinition", "subject", element.getSubject(), -1);
9566    }
9567    if (element.hasDateElement()) {
9568      composeDateTime(t, "EventDefinition", "date", element.getDateElement(), -1);
9569    }
9570    if (element.hasPublisherElement()) {
9571      composeString(t, "EventDefinition", "publisher", element.getPublisherElement(), -1);
9572    }
9573    for (int i = 0; i < element.getContact().size(); i++) {
9574      composeContactDetail(t, "EventDefinition", "contact", element.getContact().get(i), i);
9575    }
9576    if (element.hasDescriptionElement()) {
9577      composeMarkdown(t, "EventDefinition", "description", element.getDescriptionElement(), -1);
9578    }
9579    for (int i = 0; i < element.getUseContext().size(); i++) {
9580      composeUsageContext(t, "EventDefinition", "useContext", element.getUseContext().get(i), i);
9581    }
9582    for (int i = 0; i < element.getJurisdiction().size(); i++) {
9583      composeCodeableConcept(t, "EventDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
9584    }
9585    if (element.hasPurposeElement()) {
9586      composeMarkdown(t, "EventDefinition", "purpose", element.getPurposeElement(), -1);
9587    }
9588    if (element.hasUsageElement()) {
9589      composeString(t, "EventDefinition", "usage", element.getUsageElement(), -1);
9590    }
9591    if (element.hasCopyrightElement()) {
9592      composeMarkdown(t, "EventDefinition", "copyright", element.getCopyrightElement(), -1);
9593    }
9594    if (element.hasApprovalDateElement()) {
9595      composeDate(t, "EventDefinition", "approvalDate", element.getApprovalDateElement(), -1);
9596    }
9597    if (element.hasLastReviewDateElement()) {
9598      composeDate(t, "EventDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
9599    }
9600    if (element.hasEffectivePeriod()) {
9601      composePeriod(t, "EventDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
9602    }
9603    for (int i = 0; i < element.getTopic().size(); i++) {
9604      composeCodeableConcept(t, "EventDefinition", "topic", element.getTopic().get(i), i);
9605    }
9606    for (int i = 0; i < element.getAuthor().size(); i++) {
9607      composeContactDetail(t, "EventDefinition", "author", element.getAuthor().get(i), i);
9608    }
9609    for (int i = 0; i < element.getEditor().size(); i++) {
9610      composeContactDetail(t, "EventDefinition", "editor", element.getEditor().get(i), i);
9611    }
9612    for (int i = 0; i < element.getReviewer().size(); i++) {
9613      composeContactDetail(t, "EventDefinition", "reviewer", element.getReviewer().get(i), i);
9614    }
9615    for (int i = 0; i < element.getEndorser().size(); i++) {
9616      composeContactDetail(t, "EventDefinition", "endorser", element.getEndorser().get(i), i);
9617    }
9618    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
9619      composeRelatedArtifact(t, "EventDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
9620    }
9621    for (int i = 0; i < element.getTrigger().size(); i++) {
9622      composeTriggerDefinition(t, "EventDefinition", "trigger", element.getTrigger().get(i), i);
9623    }
9624  }
9625
9626  protected void composeEvidence(Complex parent, String parentType, String name, Evidence element, int index) {
9627    if (element == null) 
9628      return;
9629    Complex t;
9630    if (Utilities.noString(parentType))
9631      t = parent;
9632    else {
9633      t = parent.predicate("fhir:"+parentType+'.'+name);
9634    }
9635    composeMetadataResource(t, "Evidence", name, element, index);
9636    if (element.hasUrlElement()) {
9637      composeUri(t, "Evidence", "url", element.getUrlElement(), -1);
9638    }
9639    for (int i = 0; i < element.getIdentifier().size(); i++) {
9640      composeIdentifier(t, "Evidence", "identifier", element.getIdentifier().get(i), i);
9641    }
9642    if (element.hasVersionElement()) {
9643      composeString(t, "Evidence", "version", element.getVersionElement(), -1);
9644    }
9645    if (element.hasTitleElement()) {
9646      composeString(t, "Evidence", "title", element.getTitleElement(), -1);
9647    }
9648    if (element.hasStatusElement()) {
9649      composeEnum(t, "Evidence", "status", element.getStatusElement(), -1);
9650    }
9651    if (element.hasDateElement()) {
9652      composeDateTime(t, "Evidence", "date", element.getDateElement(), -1);
9653    }
9654    for (int i = 0; i < element.getUseContext().size(); i++) {
9655      composeUsageContext(t, "Evidence", "useContext", element.getUseContext().get(i), i);
9656    }
9657    if (element.hasApprovalDateElement()) {
9658      composeDate(t, "Evidence", "approvalDate", element.getApprovalDateElement(), -1);
9659    }
9660    if (element.hasLastReviewDateElement()) {
9661      composeDate(t, "Evidence", "lastReviewDate", element.getLastReviewDateElement(), -1);
9662    }
9663    for (int i = 0; i < element.getContributor().size(); i++) {
9664      composeContributor(t, "Evidence", "contributor", element.getContributor().get(i), i);
9665    }
9666    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
9667      composeRelatedArtifact(t, "Evidence", "relatedArtifact", element.getRelatedArtifact().get(i), i);
9668    }
9669    if (element.hasDescriptionElement()) {
9670      composeMarkdown(t, "Evidence", "description", element.getDescriptionElement(), -1);
9671    }
9672    if (element.hasAssertionElement()) {
9673      composeMarkdown(t, "Evidence", "assertion", element.getAssertionElement(), -1);
9674    }
9675    for (int i = 0; i < element.getNote().size(); i++) {
9676      composeAnnotation(t, "Evidence", "note", element.getNote().get(i), i);
9677    }
9678    if (element.hasReferentGroup()) {
9679      composeEvidenceReferentGroupComponent(t, "Evidence", "referentGroup", element.getReferentGroup(), -1);
9680    }
9681    for (int i = 0; i < element.getVariableDefinition().size(); i++) {
9682      composeEvidenceVariableDefinitionComponent(t, "Evidence", "variableDefinition", element.getVariableDefinition().get(i), i);
9683    }
9684    if (element.hasSynthesisType()) {
9685      composeCodeableConcept(t, "Evidence", "synthesisType", element.getSynthesisType(), -1);
9686    }
9687    if (element.hasStudyType()) {
9688      composeCodeableConcept(t, "Evidence", "studyType", element.getStudyType(), -1);
9689    }
9690    for (int i = 0; i < element.getStatistic().size(); i++) {
9691      composeStatistic(t, "Evidence", "statistic", element.getStatistic().get(i), i);
9692    }
9693    for (int i = 0; i < element.getDistribution().size(); i++) {
9694      composeOrderedDistribution(t, "Evidence", "distribution", element.getDistribution().get(i), i);
9695    }
9696    for (int i = 0; i < element.getCertainty().size(); i++) {
9697      composeEvidenceCertaintyComponent(t, "Evidence", "certainty", element.getCertainty().get(i), i);
9698    }
9699  }
9700
9701  protected void composeEvidenceReferentGroupComponent(Complex parent, String parentType, String name, Evidence.EvidenceReferentGroupComponent element, int index) {
9702    if (element == null) 
9703      return;
9704    Complex t;
9705    if (Utilities.noString(parentType))
9706      t = parent;
9707    else {
9708      t = parent.predicate("fhir:"+parentType+'.'+name);
9709    }
9710    composeBackboneElement(t, "referentGroup", name, element, index);
9711    if (element.hasDescriptionElement()) {
9712      composeMarkdown(t, "EvidenceReferentGroupComponent", "description", element.getDescriptionElement(), -1);
9713    }
9714    for (int i = 0; i < element.getNote().size(); i++) {
9715      composeAnnotation(t, "EvidenceReferentGroupComponent", "note", element.getNote().get(i), i);
9716    }
9717    if (element.hasEvidenceSource()) {
9718      composeReference(t, "EvidenceReferentGroupComponent", "evidenceSource", element.getEvidenceSource(), -1);
9719    }
9720    if (element.hasIntendedGroup()) {
9721      composeReference(t, "EvidenceReferentGroupComponent", "intendedGroup", element.getIntendedGroup(), -1);
9722    }
9723    if (element.hasDirectnessMatch()) {
9724      composeCodeableConcept(t, "EvidenceReferentGroupComponent", "directnessMatch", element.getDirectnessMatch(), -1);
9725    }
9726  }
9727
9728  protected void composeEvidenceVariableDefinitionComponent(Complex parent, String parentType, String name, Evidence.EvidenceVariableDefinitionComponent element, int index) {
9729    if (element == null) 
9730      return;
9731    Complex t;
9732    if (Utilities.noString(parentType))
9733      t = parent;
9734    else {
9735      t = parent.predicate("fhir:"+parentType+'.'+name);
9736    }
9737    composeBackboneElement(t, "variableDefinition", name, element, index);
9738    if (element.hasDescriptionElement()) {
9739      composeMarkdown(t, "EvidenceVariableDefinitionComponent", "description", element.getDescriptionElement(), -1);
9740    }
9741    for (int i = 0; i < element.getNote().size(); i++) {
9742      composeAnnotation(t, "EvidenceVariableDefinitionComponent", "note", element.getNote().get(i), i);
9743    }
9744    if (element.hasVariableRole()) {
9745      composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "variableRole", element.getVariableRole(), -1);
9746    }
9747    if (element.hasActualDefinition()) {
9748      composeReference(t, "EvidenceVariableDefinitionComponent", "actualDefinition", element.getActualDefinition(), -1);
9749    }
9750    if (element.hasIntendedDefinition()) {
9751      composeReference(t, "EvidenceVariableDefinitionComponent", "intendedDefinition", element.getIntendedDefinition(), -1);
9752    }
9753    if (element.hasDirectnessMatch()) {
9754      composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "directnessMatch", element.getDirectnessMatch(), -1);
9755    }
9756  }
9757
9758  protected void composeEvidenceCertaintyComponent(Complex parent, String parentType, String name, Evidence.EvidenceCertaintyComponent element, int index) {
9759    if (element == null) 
9760      return;
9761    Complex t;
9762    if (Utilities.noString(parentType))
9763      t = parent;
9764    else {
9765      t = parent.predicate("fhir:"+parentType+'.'+name);
9766    }
9767    composeBackboneElement(t, "certainty", name, element, index);
9768    if (element.hasDescriptionElement()) {
9769      composeString(t, "EvidenceCertaintyComponent", "description", element.getDescriptionElement(), -1);
9770    }
9771    if (element.hasNote()) {
9772      composeAnnotation(t, "EvidenceCertaintyComponent", "note", element.getNote(), -1);
9773    }
9774    for (int i = 0; i < element.getRating().size(); i++) {
9775      composeCodeableConcept(t, "EvidenceCertaintyComponent", "rating", element.getRating().get(i), i);
9776    }
9777    for (int i = 0; i < element.getCertaintySubcomponent().size(); i++) {
9778      composeEvidenceCertaintyCertaintySubcomponentComponent(t, "EvidenceCertaintyComponent", "certaintySubcomponent", element.getCertaintySubcomponent().get(i), i);
9779    }
9780  }
9781
9782  protected void composeEvidenceCertaintyCertaintySubcomponentComponent(Complex parent, String parentType, String name, Evidence.EvidenceCertaintyCertaintySubcomponentComponent element, int index) {
9783    if (element == null) 
9784      return;
9785    Complex t;
9786    if (Utilities.noString(parentType))
9787      t = parent;
9788    else {
9789      t = parent.predicate("fhir:"+parentType+'.'+name);
9790    }
9791    composeBackboneElement(t, "certaintySubcomponent", name, element, index);
9792    if (element.hasDescriptionElement()) {
9793      composeString(t, "EvidenceCertaintyCertaintySubcomponentComponent", "description", element.getDescriptionElement(), -1);
9794    }
9795    if (element.hasNote()) {
9796      composeAnnotation(t, "EvidenceCertaintyCertaintySubcomponentComponent", "note", element.getNote(), -1);
9797    }
9798    for (int i = 0; i < element.getType().size(); i++) {
9799      composeCodeableConcept(t, "EvidenceCertaintyCertaintySubcomponentComponent", "type", element.getType().get(i), i);
9800    }
9801    for (int i = 0; i < element.getRating().size(); i++) {
9802      composeCodeableConcept(t, "EvidenceCertaintyCertaintySubcomponentComponent", "rating", element.getRating().get(i), i);
9803    }
9804  }
9805
9806  protected void composeEvidenceVariable(Complex parent, String parentType, String name, EvidenceVariable 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    composeMetadataResource(t, "EvidenceVariable", name, element, index);
9816    if (element.hasUrlElement()) {
9817      composeUri(t, "EvidenceVariable", "url", element.getUrlElement(), -1);
9818    }
9819    for (int i = 0; i < element.getIdentifier().size(); i++) {
9820      composeIdentifier(t, "EvidenceVariable", "identifier", element.getIdentifier().get(i), i);
9821    }
9822    if (element.hasVersionElement()) {
9823      composeString(t, "EvidenceVariable", "version", element.getVersionElement(), -1);
9824    }
9825    if (element.hasNameElement()) {
9826      composeString(t, "EvidenceVariable", "name", element.getNameElement(), -1);
9827    }
9828    if (element.hasTitleElement()) {
9829      composeString(t, "EvidenceVariable", "title", element.getTitleElement(), -1);
9830    }
9831    if (element.hasShortTitleElement()) {
9832      composeString(t, "EvidenceVariable", "shortTitle", element.getShortTitleElement(), -1);
9833    }
9834    if (element.hasSubtitleElement()) {
9835      composeString(t, "EvidenceVariable", "subtitle", element.getSubtitleElement(), -1);
9836    }
9837    if (element.hasStatusElement()) {
9838      composeEnum(t, "EvidenceVariable", "status", element.getStatusElement(), -1);
9839    }
9840    if (element.hasDateElement()) {
9841      composeDateTime(t, "EvidenceVariable", "date", element.getDateElement(), -1);
9842    }
9843    if (element.hasPublisherElement()) {
9844      composeString(t, "EvidenceVariable", "publisher", element.getPublisherElement(), -1);
9845    }
9846    for (int i = 0; i < element.getContact().size(); i++) {
9847      composeContactDetail(t, "EvidenceVariable", "contact", element.getContact().get(i), i);
9848    }
9849    if (element.hasDescriptionElement()) {
9850      composeMarkdown(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1);
9851    }
9852    for (int i = 0; i < element.getNote().size(); i++) {
9853      composeAnnotation(t, "EvidenceVariable", "note", element.getNote().get(i), i);
9854    }
9855    for (int i = 0; i < element.getUseContext().size(); i++) {
9856      composeUsageContext(t, "EvidenceVariable", "useContext", element.getUseContext().get(i), i);
9857    }
9858    for (int i = 0; i < element.getJurisdiction().size(); i++) {
9859      composeCodeableConcept(t, "EvidenceVariable", "jurisdiction", element.getJurisdiction().get(i), i);
9860    }
9861    if (element.hasCopyrightElement()) {
9862      composeMarkdown(t, "EvidenceVariable", "copyright", element.getCopyrightElement(), -1);
9863    }
9864    if (element.hasApprovalDateElement()) {
9865      composeDate(t, "EvidenceVariable", "approvalDate", element.getApprovalDateElement(), -1);
9866    }
9867    if (element.hasLastReviewDateElement()) {
9868      composeDate(t, "EvidenceVariable", "lastReviewDate", element.getLastReviewDateElement(), -1);
9869    }
9870    if (element.hasEffectivePeriod()) {
9871      composePeriod(t, "EvidenceVariable", "effectivePeriod", element.getEffectivePeriod(), -1);
9872    }
9873    for (int i = 0; i < element.getTopic().size(); i++) {
9874      composeCodeableConcept(t, "EvidenceVariable", "topic", element.getTopic().get(i), i);
9875    }
9876    for (int i = 0; i < element.getAuthor().size(); i++) {
9877      composeContactDetail(t, "EvidenceVariable", "author", element.getAuthor().get(i), i);
9878    }
9879    for (int i = 0; i < element.getEditor().size(); i++) {
9880      composeContactDetail(t, "EvidenceVariable", "editor", element.getEditor().get(i), i);
9881    }
9882    for (int i = 0; i < element.getReviewer().size(); i++) {
9883      composeContactDetail(t, "EvidenceVariable", "reviewer", element.getReviewer().get(i), i);
9884    }
9885    for (int i = 0; i < element.getEndorser().size(); i++) {
9886      composeContactDetail(t, "EvidenceVariable", "endorser", element.getEndorser().get(i), i);
9887    }
9888    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
9889      composeRelatedArtifact(t, "EvidenceVariable", "relatedArtifact", element.getRelatedArtifact().get(i), i);
9890    }
9891    if (element.hasTypeElement()) {
9892      composeEnum(t, "EvidenceVariable", "type", element.getTypeElement(), -1);
9893    }
9894    if (element.hasActualElement()) {
9895      composeBoolean(t, "EvidenceVariable", "actual", element.getActualElement(), -1);
9896    }
9897    for (int i = 0; i < element.getCharacteristic().size(); i++) {
9898      composeEvidenceVariableCharacteristicComponent(t, "EvidenceVariable", "characteristic", element.getCharacteristic().get(i), i);
9899    }
9900  }
9901
9902  protected void composeEvidenceVariableCharacteristicComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicComponent element, int index) {
9903    if (element == null) 
9904      return;
9905    Complex t;
9906    if (Utilities.noString(parentType))
9907      t = parent;
9908    else {
9909      t = parent.predicate("fhir:"+parentType+'.'+name);
9910    }
9911    composeBackboneElement(t, "characteristic", name, element, index);
9912    if (element.hasDescriptionElement()) {
9913      composeString(t, "EvidenceVariableCharacteristicComponent", "description", element.getDescriptionElement(), -1);
9914    }
9915    if (element.hasDefinition()) {
9916      composeType(t, "EvidenceVariableCharacteristicComponent", "definition", element.getDefinition(), -1);
9917    }
9918    if (element.hasMethod()) {
9919      composeCodeableConcept(t, "EvidenceVariableCharacteristicComponent", "method", element.getMethod(), -1);
9920    }
9921    if (element.hasDevice()) {
9922      composeReference(t, "EvidenceVariableCharacteristicComponent", "device", element.getDevice(), -1);
9923    }
9924    for (int i = 0; i < element.getBooleanSet().size(); i++) {
9925      composeString(t, "EvidenceVariableCharacteristicComponent", "booleanSet", element.getBooleanSet().get(i), i);
9926    }
9927    if (element.hasExcludeElement()) {
9928      composeBoolean(t, "EvidenceVariableCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
9929    }
9930    if (element.hasParticipantEffective()) {
9931      composeType(t, "EvidenceVariableCharacteristicComponent", "participantEffective", element.getParticipantEffective(), -1);
9932    }
9933    if (element.hasTimeFromStart()) {
9934      composeDuration(t, "EvidenceVariableCharacteristicComponent", "timeFromStart", element.getTimeFromStart(), -1);
9935    }
9936    if (element.hasGroupMeasureElement()) {
9937      composeEnum(t, "EvidenceVariableCharacteristicComponent", "groupMeasure", element.getGroupMeasureElement(), -1);
9938    }
9939  }
9940
9941  protected void composeExampleScenario(Complex parent, String parentType, String name, ExampleScenario element, int index) {
9942    if (element == null) 
9943      return;
9944    Complex t;
9945    if (Utilities.noString(parentType))
9946      t = parent;
9947    else {
9948      t = parent.predicate("fhir:"+parentType+'.'+name);
9949    }
9950    composeCanonicalResource(t, "ExampleScenario", name, element, index);
9951    if (element.hasUrlElement()) {
9952      composeUri(t, "ExampleScenario", "url", element.getUrlElement(), -1);
9953    }
9954    for (int i = 0; i < element.getIdentifier().size(); i++) {
9955      composeIdentifier(t, "ExampleScenario", "identifier", element.getIdentifier().get(i), i);
9956    }
9957    if (element.hasVersionElement()) {
9958      composeString(t, "ExampleScenario", "version", element.getVersionElement(), -1);
9959    }
9960    if (element.hasNameElement()) {
9961      composeString(t, "ExampleScenario", "name", element.getNameElement(), -1);
9962    }
9963    if (element.hasStatusElement()) {
9964      composeEnum(t, "ExampleScenario", "status", element.getStatusElement(), -1);
9965    }
9966    if (element.hasExperimentalElement()) {
9967      composeBoolean(t, "ExampleScenario", "experimental", element.getExperimentalElement(), -1);
9968    }
9969    if (element.hasDateElement()) {
9970      composeDateTime(t, "ExampleScenario", "date", element.getDateElement(), -1);
9971    }
9972    if (element.hasPublisherElement()) {
9973      composeString(t, "ExampleScenario", "publisher", element.getPublisherElement(), -1);
9974    }
9975    for (int i = 0; i < element.getContact().size(); i++) {
9976      composeContactDetail(t, "ExampleScenario", "contact", element.getContact().get(i), i);
9977    }
9978    for (int i = 0; i < element.getUseContext().size(); i++) {
9979      composeUsageContext(t, "ExampleScenario", "useContext", element.getUseContext().get(i), i);
9980    }
9981    for (int i = 0; i < element.getJurisdiction().size(); i++) {
9982      composeCodeableConcept(t, "ExampleScenario", "jurisdiction", element.getJurisdiction().get(i), i);
9983    }
9984    if (element.hasPurposeElement()) {
9985      composeMarkdown(t, "ExampleScenario", "purpose", element.getPurposeElement(), -1);
9986    }
9987    if (element.hasCopyrightElement()) {
9988      composeMarkdown(t, "ExampleScenario", "copyright", element.getCopyrightElement(), -1);
9989    }
9990    for (int i = 0; i < element.getActor().size(); i++) {
9991      composeExampleScenarioActorComponent(t, "ExampleScenario", "actor", element.getActor().get(i), i);
9992    }
9993    for (int i = 0; i < element.getInstance().size(); i++) {
9994      composeExampleScenarioInstanceComponent(t, "ExampleScenario", "instance", element.getInstance().get(i), i);
9995    }
9996    for (int i = 0; i < element.getProcess().size(); i++) {
9997      composeExampleScenarioProcessComponent(t, "ExampleScenario", "process", element.getProcess().get(i), i);
9998    }
9999    for (int i = 0; i < element.getWorkflow().size(); i++) {
10000      composeCanonical(t, "ExampleScenario", "workflow", element.getWorkflow().get(i), i);
10001    }
10002  }
10003
10004  protected void composeExampleScenarioActorComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioActorComponent element, int index) {
10005    if (element == null) 
10006      return;
10007    Complex t;
10008    if (Utilities.noString(parentType))
10009      t = parent;
10010    else {
10011      t = parent.predicate("fhir:"+parentType+'.'+name);
10012    }
10013    composeBackboneElement(t, "actor", name, element, index);
10014    if (element.hasActorIdElement()) {
10015      composeString(t, "ExampleScenarioActorComponent", "actorId", element.getActorIdElement(), -1);
10016    }
10017    if (element.hasTypeElement()) {
10018      composeEnum(t, "ExampleScenarioActorComponent", "type", element.getTypeElement(), -1);
10019    }
10020    if (element.hasNameElement()) {
10021      composeString(t, "ExampleScenarioActorComponent", "name", element.getNameElement(), -1);
10022    }
10023    if (element.hasDescriptionElement()) {
10024      composeMarkdown(t, "ExampleScenarioActorComponent", "description", element.getDescriptionElement(), -1);
10025    }
10026  }
10027
10028  protected void composeExampleScenarioInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceComponent element, int index) {
10029    if (element == null) 
10030      return;
10031    Complex t;
10032    if (Utilities.noString(parentType))
10033      t = parent;
10034    else {
10035      t = parent.predicate("fhir:"+parentType+'.'+name);
10036    }
10037    composeBackboneElement(t, "instance", name, element, index);
10038    if (element.hasResourceIdElement()) {
10039      composeString(t, "ExampleScenarioInstanceComponent", "resourceId", element.getResourceIdElement(), -1);
10040    }
10041    if (element.hasResourceTypeElement()) {
10042      composeCode(t, "ExampleScenarioInstanceComponent", "resourceType", element.getResourceTypeElement(), -1);
10043    }
10044    if (element.hasNameElement()) {
10045      composeString(t, "ExampleScenarioInstanceComponent", "name", element.getNameElement(), -1);
10046    }
10047    if (element.hasDescriptionElement()) {
10048      composeMarkdown(t, "ExampleScenarioInstanceComponent", "description", element.getDescriptionElement(), -1);
10049    }
10050    for (int i = 0; i < element.getVersion().size(); i++) {
10051      composeExampleScenarioInstanceVersionComponent(t, "ExampleScenarioInstanceComponent", "version", element.getVersion().get(i), i);
10052    }
10053    for (int i = 0; i < element.getContainedInstance().size(); i++) {
10054      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioInstanceComponent", "containedInstance", element.getContainedInstance().get(i), i);
10055    }
10056  }
10057
10058  protected void composeExampleScenarioInstanceVersionComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceVersionComponent element, int index) {
10059    if (element == null) 
10060      return;
10061    Complex t;
10062    if (Utilities.noString(parentType))
10063      t = parent;
10064    else {
10065      t = parent.predicate("fhir:"+parentType+'.'+name);
10066    }
10067    composeBackboneElement(t, "version", name, element, index);
10068    if (element.hasVersionIdElement()) {
10069      composeString(t, "ExampleScenarioInstanceVersionComponent", "versionId", element.getVersionIdElement(), -1);
10070    }
10071    if (element.hasDescriptionElement()) {
10072      composeMarkdown(t, "ExampleScenarioInstanceVersionComponent", "description", element.getDescriptionElement(), -1);
10073    }
10074  }
10075
10076  protected void composeExampleScenarioInstanceContainedInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceContainedInstanceComponent element, int index) {
10077    if (element == null) 
10078      return;
10079    Complex t;
10080    if (Utilities.noString(parentType))
10081      t = parent;
10082    else {
10083      t = parent.predicate("fhir:"+parentType+'.'+name);
10084    }
10085    composeBackboneElement(t, "containedInstance", name, element, index);
10086    if (element.hasResourceIdElement()) {
10087      composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "resourceId", element.getResourceIdElement(), -1);
10088    }
10089    if (element.hasVersionIdElement()) {
10090      composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "versionId", element.getVersionIdElement(), -1);
10091    }
10092  }
10093
10094  protected void composeExampleScenarioProcessComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessComponent element, int index) {
10095    if (element == null) 
10096      return;
10097    Complex t;
10098    if (Utilities.noString(parentType))
10099      t = parent;
10100    else {
10101      t = parent.predicate("fhir:"+parentType+'.'+name);
10102    }
10103    composeBackboneElement(t, "process", name, element, index);
10104    if (element.hasTitleElement()) {
10105      composeString(t, "ExampleScenarioProcessComponent", "title", element.getTitleElement(), -1);
10106    }
10107    if (element.hasDescriptionElement()) {
10108      composeMarkdown(t, "ExampleScenarioProcessComponent", "description", element.getDescriptionElement(), -1);
10109    }
10110    if (element.hasPreConditionsElement()) {
10111      composeMarkdown(t, "ExampleScenarioProcessComponent", "preConditions", element.getPreConditionsElement(), -1);
10112    }
10113    if (element.hasPostConditionsElement()) {
10114      composeMarkdown(t, "ExampleScenarioProcessComponent", "postConditions", element.getPostConditionsElement(), -1);
10115    }
10116    for (int i = 0; i < element.getStep().size(); i++) {
10117      composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessComponent", "step", element.getStep().get(i), i);
10118    }
10119  }
10120
10121  protected void composeExampleScenarioProcessStepComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepComponent 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, "step", name, element, index);
10131    for (int i = 0; i < element.getProcess().size(); i++) {
10132      composeExampleScenarioProcessComponent(t, "ExampleScenarioProcessStepComponent", "process", element.getProcess().get(i), i);
10133    }
10134    if (element.hasPauseElement()) {
10135      composeBoolean(t, "ExampleScenarioProcessStepComponent", "pause", element.getPauseElement(), -1);
10136    }
10137    if (element.hasOperation()) {
10138      composeExampleScenarioProcessStepOperationComponent(t, "ExampleScenarioProcessStepComponent", "operation", element.getOperation(), -1);
10139    }
10140    for (int i = 0; i < element.getAlternative().size(); i++) {
10141      composeExampleScenarioProcessStepAlternativeComponent(t, "ExampleScenarioProcessStepComponent", "alternative", element.getAlternative().get(i), i);
10142    }
10143  }
10144
10145  protected void composeExampleScenarioProcessStepOperationComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepOperationComponent element, int index) {
10146    if (element == null) 
10147      return;
10148    Complex t;
10149    if (Utilities.noString(parentType))
10150      t = parent;
10151    else {
10152      t = parent.predicate("fhir:"+parentType+'.'+name);
10153    }
10154    composeBackboneElement(t, "operation", name, element, index);
10155    if (element.hasNumberElement()) {
10156      composeString(t, "ExampleScenarioProcessStepOperationComponent", "number", element.getNumberElement(), -1);
10157    }
10158    if (element.hasTypeElement()) {
10159      composeString(t, "ExampleScenarioProcessStepOperationComponent", "type", element.getTypeElement(), -1);
10160    }
10161    if (element.hasNameElement()) {
10162      composeString(t, "ExampleScenarioProcessStepOperationComponent", "name", element.getNameElement(), -1);
10163    }
10164    if (element.hasInitiatorElement()) {
10165      composeString(t, "ExampleScenarioProcessStepOperationComponent", "initiator", element.getInitiatorElement(), -1);
10166    }
10167    if (element.hasReceiverElement()) {
10168      composeString(t, "ExampleScenarioProcessStepOperationComponent", "receiver", element.getReceiverElement(), -1);
10169    }
10170    if (element.hasDescriptionElement()) {
10171      composeMarkdown(t, "ExampleScenarioProcessStepOperationComponent", "description", element.getDescriptionElement(), -1);
10172    }
10173    if (element.hasInitiatorActiveElement()) {
10174      composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "initiatorActive", element.getInitiatorActiveElement(), -1);
10175    }
10176    if (element.hasReceiverActiveElement()) {
10177      composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "receiverActive", element.getReceiverActiveElement(), -1);
10178    }
10179    if (element.hasRequest()) {
10180      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "request", element.getRequest(), -1);
10181    }
10182    if (element.hasResponse()) {
10183      composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "response", element.getResponse(), -1);
10184    }
10185  }
10186
10187  protected void composeExampleScenarioProcessStepAlternativeComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepAlternativeComponent element, int index) {
10188    if (element == null) 
10189      return;
10190    Complex t;
10191    if (Utilities.noString(parentType))
10192      t = parent;
10193    else {
10194      t = parent.predicate("fhir:"+parentType+'.'+name);
10195    }
10196    composeBackboneElement(t, "alternative", name, element, index);
10197    if (element.hasTitleElement()) {
10198      composeString(t, "ExampleScenarioProcessStepAlternativeComponent", "title", element.getTitleElement(), -1);
10199    }
10200    if (element.hasDescriptionElement()) {
10201      composeMarkdown(t, "ExampleScenarioProcessStepAlternativeComponent", "description", element.getDescriptionElement(), -1);
10202    }
10203    for (int i = 0; i < element.getStep().size(); i++) {
10204      composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessStepAlternativeComponent", "step", element.getStep().get(i), i);
10205    }
10206  }
10207
10208  protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) {
10209    if (element == null) 
10210      return;
10211    Complex t;
10212    if (Utilities.noString(parentType))
10213      t = parent;
10214    else {
10215      t = parent.predicate("fhir:"+parentType+'.'+name);
10216    }
10217    composeDomainResource(t, "ExplanationOfBenefit", name, element, index);
10218    for (int i = 0; i < element.getIdentifier().size(); i++) {
10219      composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i);
10220    }
10221    if (element.hasStatusElement()) {
10222      composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1);
10223    }
10224    if (element.hasType()) {
10225      composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1);
10226    }
10227    if (element.hasSubType()) {
10228      composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType(), -1);
10229    }
10230    if (element.hasUseElement()) {
10231      composeEnum(t, "ExplanationOfBenefit", "use", element.getUseElement(), -1);
10232    }
10233    if (element.hasPatient()) {
10234      composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1);
10235    }
10236    if (element.hasBillablePeriod()) {
10237      composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1);
10238    }
10239    if (element.hasCreatedElement()) {
10240      composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1);
10241    }
10242    if (element.hasEnterer()) {
10243      composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1);
10244    }
10245    if (element.hasInsurer()) {
10246      composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1);
10247    }
10248    if (element.hasProvider()) {
10249      composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1);
10250    }
10251    if (element.hasPriority()) {
10252      composeCodeableConcept(t, "ExplanationOfBenefit", "priority", element.getPriority(), -1);
10253    }
10254    if (element.hasFundsReserveRequested()) {
10255      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserveRequested", element.getFundsReserveRequested(), -1);
10256    }
10257    if (element.hasFundsReserve()) {
10258      composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserve", element.getFundsReserve(), -1);
10259    }
10260    for (int i = 0; i < element.getRelated().size(); i++) {
10261      composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i);
10262    }
10263    if (element.hasPrescription()) {
10264      composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1);
10265    }
10266    if (element.hasOriginalPrescription()) {
10267      composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1);
10268    }
10269    if (element.hasPayee()) {
10270      composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1);
10271    }
10272    if (element.hasReferral()) {
10273      composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1);
10274    }
10275    if (element.hasFacility()) {
10276      composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1);
10277    }
10278    if (element.hasClaim()) {
10279      composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1);
10280    }
10281    if (element.hasClaimResponse()) {
10282      composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1);
10283    }
10284    if (element.hasOutcomeElement()) {
10285      composeEnum(t, "ExplanationOfBenefit", "outcome", element.getOutcomeElement(), -1);
10286    }
10287    if (element.hasDispositionElement()) {
10288      composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1);
10289    }
10290    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
10291      composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i);
10292    }
10293    for (int i = 0; i < element.getPreAuthRefPeriod().size(); i++) {
10294      composePeriod(t, "ExplanationOfBenefit", "preAuthRefPeriod", element.getPreAuthRefPeriod().get(i), i);
10295    }
10296    for (int i = 0; i < element.getCareTeam().size(); i++) {
10297      composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i);
10298    }
10299    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
10300      composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "supportingInfo", element.getSupportingInfo().get(i), i);
10301    }
10302    for (int i = 0; i < element.getDiagnosis().size(); i++) {
10303      composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i);
10304    }
10305    for (int i = 0; i < element.getProcedure().size(); i++) {
10306      composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i);
10307    }
10308    if (element.hasPrecedenceElement()) {
10309      composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1);
10310    }
10311    for (int i = 0; i < element.getInsurance().size(); i++) {
10312      composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance().get(i), i);
10313    }
10314    if (element.hasAccident()) {
10315      composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1);
10316    }
10317    for (int i = 0; i < element.getItem().size(); i++) {
10318      composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i);
10319    }
10320    for (int i = 0; i < element.getAddItem().size(); i++) {
10321      composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i);
10322    }
10323    for (int i = 0; i < element.getAdjudication().size(); i++) {
10324      composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i);
10325    }
10326    for (int i = 0; i < element.getTotal().size(); i++) {
10327      composeExplanationOfBenefitTotalComponent(t, "ExplanationOfBenefit", "total", element.getTotal().get(i), i);
10328    }
10329    if (element.hasPayment()) {
10330      composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1);
10331    }
10332    if (element.hasFormCode()) {
10333      composeCodeableConcept(t, "ExplanationOfBenefit", "formCode", element.getFormCode(), -1);
10334    }
10335    if (element.hasForm()) {
10336      composeAttachment(t, "ExplanationOfBenefit", "form", element.getForm(), -1);
10337    }
10338    for (int i = 0; i < element.getProcessNote().size(); i++) {
10339      composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i);
10340    }
10341    if (element.hasBenefitPeriod()) {
10342      composePeriod(t, "ExplanationOfBenefit", "benefitPeriod", element.getBenefitPeriod(), -1);
10343    }
10344    for (int i = 0; i < element.getBenefitBalance().size(); i++) {
10345      composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i);
10346    }
10347  }
10348
10349  protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) {
10350    if (element == null) 
10351      return;
10352    Complex t;
10353    if (Utilities.noString(parentType))
10354      t = parent;
10355    else {
10356      t = parent.predicate("fhir:"+parentType+'.'+name);
10357    }
10358    composeBackboneElement(t, "related", name, element, index);
10359    if (element.hasClaim()) {
10360      composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1);
10361    }
10362    if (element.hasRelationship()) {
10363      composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1);
10364    }
10365    if (element.hasReference()) {
10366      composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1);
10367    }
10368  }
10369
10370  protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) {
10371    if (element == null) 
10372      return;
10373    Complex t;
10374    if (Utilities.noString(parentType))
10375      t = parent;
10376    else {
10377      t = parent.predicate("fhir:"+parentType+'.'+name);
10378    }
10379    composeBackboneElement(t, "payee", name, element, index);
10380    if (element.hasType()) {
10381      composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1);
10382    }
10383    if (element.hasParty()) {
10384      composeReference(t, "PayeeComponent", "party", element.getParty(), -1);
10385    }
10386  }
10387
10388  protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) {
10389    if (element == null) 
10390      return;
10391    Complex t;
10392    if (Utilities.noString(parentType))
10393      t = parent;
10394    else {
10395      t = parent.predicate("fhir:"+parentType+'.'+name);
10396    }
10397    composeBackboneElement(t, "careTeam", name, element, index);
10398    if (element.hasSequenceElement()) {
10399      composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1);
10400    }
10401    if (element.hasProvider()) {
10402      composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1);
10403    }
10404    if (element.hasResponsibleElement()) {
10405      composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1);
10406    }
10407    if (element.hasRole()) {
10408      composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1);
10409    }
10410    if (element.hasQualification()) {
10411      composeCodeableConcept(t, "CareTeamComponent", "qualification", element.getQualification(), -1);
10412    }
10413  }
10414
10415  protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) {
10416    if (element == null) 
10417      return;
10418    Complex t;
10419    if (Utilities.noString(parentType))
10420      t = parent;
10421    else {
10422      t = parent.predicate("fhir:"+parentType+'.'+name);
10423    }
10424    composeBackboneElement(t, "supportingInfo", name, element, index);
10425    if (element.hasSequenceElement()) {
10426      composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1);
10427    }
10428    if (element.hasCategory()) {
10429      composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1);
10430    }
10431    if (element.hasCode()) {
10432      composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1);
10433    }
10434    if (element.hasTiming()) {
10435      composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1);
10436    }
10437    if (element.hasValue()) {
10438      composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1);
10439    }
10440    if (element.hasReason()) {
10441      composeCoding(t, "SupportingInformationComponent", "reason", element.getReason(), -1);
10442    }
10443  }
10444
10445  protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) {
10446    if (element == null) 
10447      return;
10448    Complex t;
10449    if (Utilities.noString(parentType))
10450      t = parent;
10451    else {
10452      t = parent.predicate("fhir:"+parentType+'.'+name);
10453    }
10454    composeBackboneElement(t, "diagnosis", name, element, index);
10455    if (element.hasSequenceElement()) {
10456      composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1);
10457    }
10458    if (element.hasDiagnosis()) {
10459      composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1);
10460    }
10461    for (int i = 0; i < element.getType().size(); i++) {
10462      composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i);
10463    }
10464    if (element.hasOnAdmission()) {
10465      composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1);
10466    }
10467    if (element.hasPackageCode()) {
10468      composeCodeableConcept(t, "DiagnosisComponent", "packageCode", element.getPackageCode(), -1);
10469    }
10470  }
10471
10472  protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) {
10473    if (element == null) 
10474      return;
10475    Complex t;
10476    if (Utilities.noString(parentType))
10477      t = parent;
10478    else {
10479      t = parent.predicate("fhir:"+parentType+'.'+name);
10480    }
10481    composeBackboneElement(t, "procedure", name, element, index);
10482    if (element.hasSequenceElement()) {
10483      composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1);
10484    }
10485    for (int i = 0; i < element.getType().size(); i++) {
10486      composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i);
10487    }
10488    if (element.hasDateElement()) {
10489      composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1);
10490    }
10491    if (element.hasProcedure()) {
10492      composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1);
10493    }
10494    for (int i = 0; i < element.getUdi().size(); i++) {
10495      composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i);
10496    }
10497  }
10498
10499  protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) {
10500    if (element == null) 
10501      return;
10502    Complex t;
10503    if (Utilities.noString(parentType))
10504      t = parent;
10505    else {
10506      t = parent.predicate("fhir:"+parentType+'.'+name);
10507    }
10508    composeBackboneElement(t, "insurance", name, element, index);
10509    if (element.hasFocalElement()) {
10510      composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1);
10511    }
10512    if (element.hasCoverage()) {
10513      composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1);
10514    }
10515    for (int i = 0; i < element.getPreAuthRef().size(); i++) {
10516      composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i);
10517    }
10518  }
10519
10520  protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) {
10521    if (element == null) 
10522      return;
10523    Complex t;
10524    if (Utilities.noString(parentType))
10525      t = parent;
10526    else {
10527      t = parent.predicate("fhir:"+parentType+'.'+name);
10528    }
10529    composeBackboneElement(t, "accident", name, element, index);
10530    if (element.hasDateElement()) {
10531      composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1);
10532    }
10533    if (element.hasType()) {
10534      composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1);
10535    }
10536    if (element.hasLocation()) {
10537      composeType(t, "AccidentComponent", "location", element.getLocation(), -1);
10538    }
10539  }
10540
10541  protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) {
10542    if (element == null) 
10543      return;
10544    Complex t;
10545    if (Utilities.noString(parentType))
10546      t = parent;
10547    else {
10548      t = parent.predicate("fhir:"+parentType+'.'+name);
10549    }
10550    composeBackboneElement(t, "item", name, element, index);
10551    if (element.hasSequenceElement()) {
10552      composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1);
10553    }
10554    for (int i = 0; i < element.getCareTeamSequence().size(); i++) {
10555      composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i);
10556    }
10557    for (int i = 0; i < element.getDiagnosisSequence().size(); i++) {
10558      composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i);
10559    }
10560    for (int i = 0; i < element.getProcedureSequence().size(); i++) {
10561      composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i);
10562    }
10563    for (int i = 0; i < element.getInformationSequence().size(); i++) {
10564      composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i);
10565    }
10566    if (element.hasRevenue()) {
10567      composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1);
10568    }
10569    if (element.hasCategory()) {
10570      composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1);
10571    }
10572    if (element.hasProductOrService()) {
10573      composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1);
10574    }
10575    for (int i = 0; i < element.getModifier().size(); i++) {
10576      composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i);
10577    }
10578    for (int i = 0; i < element.getProgramCode().size(); i++) {
10579      composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i);
10580    }
10581    if (element.hasServiced()) {
10582      composeType(t, "ItemComponent", "serviced", element.getServiced(), -1);
10583    }
10584    if (element.hasLocation()) {
10585      composeType(t, "ItemComponent", "location", element.getLocation(), -1);
10586    }
10587    if (element.hasQuantity()) {
10588      composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1);
10589    }
10590    if (element.hasUnitPrice()) {
10591      composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1);
10592    }
10593    if (element.hasFactorElement()) {
10594      composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1);
10595    }
10596    if (element.hasNet()) {
10597      composeMoney(t, "ItemComponent", "net", element.getNet(), -1);
10598    }
10599    for (int i = 0; i < element.getUdi().size(); i++) {
10600      composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i);
10601    }
10602    if (element.hasBodySite()) {
10603      composeCodeableConcept(t, "ItemComponent", "bodySite", element.getBodySite(), -1);
10604    }
10605    for (int i = 0; i < element.getSubSite().size(); i++) {
10606      composeCodeableConcept(t, "ItemComponent", "subSite", element.getSubSite().get(i), i);
10607    }
10608    for (int i = 0; i < element.getEncounter().size(); i++) {
10609      composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i);
10610    }
10611    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10612      composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
10613    }
10614    for (int i = 0; i < element.getAdjudication().size(); i++) {
10615      composeExplanationOfBenefitAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i);
10616    }
10617    for (int i = 0; i < element.getDetail().size(); i++) {
10618      composeExplanationOfBenefitDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i);
10619    }
10620  }
10621
10622  protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) {
10623    if (element == null) 
10624      return;
10625    Complex t;
10626    if (Utilities.noString(parentType))
10627      t = parent;
10628    else {
10629      t = parent.predicate("fhir:"+parentType+'.'+name);
10630    }
10631    composeBackboneElement(t, "adjudication", name, element, index);
10632    if (element.hasCategory()) {
10633      composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1);
10634    }
10635    if (element.hasReason()) {
10636      composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1);
10637    }
10638    if (element.hasAmount()) {
10639      composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1);
10640    }
10641    if (element.hasValueElement()) {
10642      composeDecimal(t, "AdjudicationComponent", "value", element.getValueElement(), -1);
10643    }
10644  }
10645
10646  protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) {
10647    if (element == null) 
10648      return;
10649    Complex t;
10650    if (Utilities.noString(parentType))
10651      t = parent;
10652    else {
10653      t = parent.predicate("fhir:"+parentType+'.'+name);
10654    }
10655    composeBackboneElement(t, "detail", name, element, index);
10656    if (element.hasSequenceElement()) {
10657      composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1);
10658    }
10659    if (element.hasRevenue()) {
10660      composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1);
10661    }
10662    if (element.hasCategory()) {
10663      composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1);
10664    }
10665    if (element.hasProductOrService()) {
10666      composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1);
10667    }
10668    for (int i = 0; i < element.getModifier().size(); i++) {
10669      composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i);
10670    }
10671    for (int i = 0; i < element.getProgramCode().size(); i++) {
10672      composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i);
10673    }
10674    if (element.hasQuantity()) {
10675      composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1);
10676    }
10677    if (element.hasUnitPrice()) {
10678      composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1);
10679    }
10680    if (element.hasFactorElement()) {
10681      composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1);
10682    }
10683    if (element.hasNet()) {
10684      composeMoney(t, "DetailComponent", "net", element.getNet(), -1);
10685    }
10686    for (int i = 0; i < element.getUdi().size(); i++) {
10687      composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i);
10688    }
10689    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10690      composePositiveInt(t, "DetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
10691    }
10692    for (int i = 0; i < element.getAdjudication().size(); i++) {
10693      composeExplanationOfBenefitAdjudicationComponent(t, "DetailComponent", "adjudication", element.getAdjudication().get(i), i);
10694    }
10695    for (int i = 0; i < element.getSubDetail().size(); i++) {
10696      composeExplanationOfBenefitSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i);
10697    }
10698  }
10699
10700  protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) {
10701    if (element == null) 
10702      return;
10703    Complex t;
10704    if (Utilities.noString(parentType))
10705      t = parent;
10706    else {
10707      t = parent.predicate("fhir:"+parentType+'.'+name);
10708    }
10709    composeBackboneElement(t, "subDetail", name, element, index);
10710    if (element.hasSequenceElement()) {
10711      composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1);
10712    }
10713    if (element.hasRevenue()) {
10714      composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1);
10715    }
10716    if (element.hasCategory()) {
10717      composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1);
10718    }
10719    if (element.hasProductOrService()) {
10720      composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1);
10721    }
10722    for (int i = 0; i < element.getModifier().size(); i++) {
10723      composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i);
10724    }
10725    for (int i = 0; i < element.getProgramCode().size(); i++) {
10726      composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i);
10727    }
10728    if (element.hasQuantity()) {
10729      composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1);
10730    }
10731    if (element.hasUnitPrice()) {
10732      composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
10733    }
10734    if (element.hasFactorElement()) {
10735      composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1);
10736    }
10737    if (element.hasNet()) {
10738      composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1);
10739    }
10740    for (int i = 0; i < element.getUdi().size(); i++) {
10741      composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i);
10742    }
10743    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10744      composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
10745    }
10746    for (int i = 0; i < element.getAdjudication().size(); i++) {
10747      composeExplanationOfBenefitAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
10748    }
10749  }
10750
10751  protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) {
10752    if (element == null) 
10753      return;
10754    Complex t;
10755    if (Utilities.noString(parentType))
10756      t = parent;
10757    else {
10758      t = parent.predicate("fhir:"+parentType+'.'+name);
10759    }
10760    composeBackboneElement(t, "addItem", name, element, index);
10761    for (int i = 0; i < element.getItemSequence().size(); i++) {
10762      composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i);
10763    }
10764    for (int i = 0; i < element.getDetailSequence().size(); i++) {
10765      composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i);
10766    }
10767    for (int i = 0; i < element.getSubDetailSequence().size(); i++) {
10768      composePositiveInt(t, "AddedItemComponent", "subDetailSequence", element.getSubDetailSequence().get(i), i);
10769    }
10770    for (int i = 0; i < element.getProvider().size(); i++) {
10771      composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i);
10772    }
10773    if (element.hasProductOrService()) {
10774      composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1);
10775    }
10776    for (int i = 0; i < element.getModifier().size(); i++) {
10777      composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i);
10778    }
10779    for (int i = 0; i < element.getProgramCode().size(); i++) {
10780      composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i);
10781    }
10782    if (element.hasServiced()) {
10783      composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1);
10784    }
10785    if (element.hasLocation()) {
10786      composeType(t, "AddedItemComponent", "location", element.getLocation(), -1);
10787    }
10788    if (element.hasQuantity()) {
10789      composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1);
10790    }
10791    if (element.hasUnitPrice()) {
10792      composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1);
10793    }
10794    if (element.hasFactorElement()) {
10795      composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1);
10796    }
10797    if (element.hasNet()) {
10798      composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1);
10799    }
10800    if (element.hasBodySite()) {
10801      composeCodeableConcept(t, "AddedItemComponent", "bodySite", element.getBodySite(), -1);
10802    }
10803    for (int i = 0; i < element.getSubSite().size(); i++) {
10804      composeCodeableConcept(t, "AddedItemComponent", "subSite", element.getSubSite().get(i), i);
10805    }
10806    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10807      composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i);
10808    }
10809    for (int i = 0; i < element.getAdjudication().size(); i++) {
10810      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i);
10811    }
10812    for (int i = 0; i < element.getDetail().size(); i++) {
10813      composeExplanationOfBenefitAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i);
10814    }
10815  }
10816
10817  protected void composeExplanationOfBenefitAddedItemDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailComponent element, int index) {
10818    if (element == null) 
10819      return;
10820    Complex t;
10821    if (Utilities.noString(parentType))
10822      t = parent;
10823    else {
10824      t = parent.predicate("fhir:"+parentType+'.'+name);
10825    }
10826    composeBackboneElement(t, "detail", name, element, index);
10827    if (element.hasProductOrService()) {
10828      composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1);
10829    }
10830    for (int i = 0; i < element.getModifier().size(); i++) {
10831      composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i);
10832    }
10833    if (element.hasQuantity()) {
10834      composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1);
10835    }
10836    if (element.hasUnitPrice()) {
10837      composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1);
10838    }
10839    if (element.hasFactorElement()) {
10840      composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1);
10841    }
10842    if (element.hasNet()) {
10843      composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1);
10844    }
10845    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10846      composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
10847    }
10848    for (int i = 0; i < element.getAdjudication().size(); i++) {
10849      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i);
10850    }
10851    for (int i = 0; i < element.getSubDetail().size(); i++) {
10852      composeExplanationOfBenefitAddedItemDetailSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i);
10853    }
10854  }
10855
10856  protected void composeExplanationOfBenefitAddedItemDetailSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailSubDetailComponent element, int index) {
10857    if (element == null) 
10858      return;
10859    Complex t;
10860    if (Utilities.noString(parentType))
10861      t = parent;
10862    else {
10863      t = parent.predicate("fhir:"+parentType+'.'+name);
10864    }
10865    composeBackboneElement(t, "subDetail", name, element, index);
10866    if (element.hasProductOrService()) {
10867      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "productOrService", element.getProductOrService(), -1);
10868    }
10869    for (int i = 0; i < element.getModifier().size(); i++) {
10870      composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "modifier", element.getModifier().get(i), i);
10871    }
10872    if (element.hasQuantity()) {
10873      composeQuantity(t, "AddedItemDetailSubDetailComponent", "quantity", element.getQuantity(), -1);
10874    }
10875    if (element.hasUnitPrice()) {
10876      composeMoney(t, "AddedItemDetailSubDetailComponent", "unitPrice", element.getUnitPrice(), -1);
10877    }
10878    if (element.hasFactorElement()) {
10879      composeDecimal(t, "AddedItemDetailSubDetailComponent", "factor", element.getFactorElement(), -1);
10880    }
10881    if (element.hasNet()) {
10882      composeMoney(t, "AddedItemDetailSubDetailComponent", "net", element.getNet(), -1);
10883    }
10884    for (int i = 0; i < element.getNoteNumber().size(); i++) {
10885      composePositiveInt(t, "AddedItemDetailSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i);
10886    }
10887    for (int i = 0; i < element.getAdjudication().size(); i++) {
10888      composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailSubDetailComponent", "adjudication", element.getAdjudication().get(i), i);
10889    }
10890  }
10891
10892  protected void composeExplanationOfBenefitTotalComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.TotalComponent element, int index) {
10893    if (element == null) 
10894      return;
10895    Complex t;
10896    if (Utilities.noString(parentType))
10897      t = parent;
10898    else {
10899      t = parent.predicate("fhir:"+parentType+'.'+name);
10900    }
10901    composeBackboneElement(t, "total", name, element, index);
10902    if (element.hasCategory()) {
10903      composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1);
10904    }
10905    if (element.hasAmount()) {
10906      composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1);
10907    }
10908  }
10909
10910  protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) {
10911    if (element == null) 
10912      return;
10913    Complex t;
10914    if (Utilities.noString(parentType))
10915      t = parent;
10916    else {
10917      t = parent.predicate("fhir:"+parentType+'.'+name);
10918    }
10919    composeBackboneElement(t, "payment", name, element, index);
10920    if (element.hasType()) {
10921      composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1);
10922    }
10923    if (element.hasAdjustment()) {
10924      composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1);
10925    }
10926    if (element.hasAdjustmentReason()) {
10927      composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1);
10928    }
10929    if (element.hasDateElement()) {
10930      composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1);
10931    }
10932    if (element.hasAmount()) {
10933      composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1);
10934    }
10935    if (element.hasIdentifier()) {
10936      composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1);
10937    }
10938  }
10939
10940  protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) {
10941    if (element == null) 
10942      return;
10943    Complex t;
10944    if (Utilities.noString(parentType))
10945      t = parent;
10946    else {
10947      t = parent.predicate("fhir:"+parentType+'.'+name);
10948    }
10949    composeBackboneElement(t, "processNote", name, element, index);
10950    if (element.hasNumberElement()) {
10951      composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1);
10952    }
10953    if (element.hasTypeElement()) {
10954      composeEnum(t, "NoteComponent", "type", element.getTypeElement(), -1);
10955    }
10956    if (element.hasTextElement()) {
10957      composeString(t, "NoteComponent", "text", element.getTextElement(), -1);
10958    }
10959    if (element.hasLanguage()) {
10960      composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1);
10961    }
10962  }
10963
10964  protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) {
10965    if (element == null) 
10966      return;
10967    Complex t;
10968    if (Utilities.noString(parentType))
10969      t = parent;
10970    else {
10971      t = parent.predicate("fhir:"+parentType+'.'+name);
10972    }
10973    composeBackboneElement(t, "benefitBalance", name, element, index);
10974    if (element.hasCategory()) {
10975      composeCodeableConcept(t, "BenefitBalanceComponent", "category", element.getCategory(), -1);
10976    }
10977    if (element.hasExcludedElement()) {
10978      composeBoolean(t, "BenefitBalanceComponent", "excluded", element.getExcludedElement(), -1);
10979    }
10980    if (element.hasNameElement()) {
10981      composeString(t, "BenefitBalanceComponent", "name", element.getNameElement(), -1);
10982    }
10983    if (element.hasDescriptionElement()) {
10984      composeString(t, "BenefitBalanceComponent", "description", element.getDescriptionElement(), -1);
10985    }
10986    if (element.hasNetwork()) {
10987      composeCodeableConcept(t, "BenefitBalanceComponent", "network", element.getNetwork(), -1);
10988    }
10989    if (element.hasUnit()) {
10990      composeCodeableConcept(t, "BenefitBalanceComponent", "unit", element.getUnit(), -1);
10991    }
10992    if (element.hasTerm()) {
10993      composeCodeableConcept(t, "BenefitBalanceComponent", "term", element.getTerm(), -1);
10994    }
10995    for (int i = 0; i < element.getFinancial().size(); i++) {
10996      composeExplanationOfBenefitBenefitComponent(t, "BenefitBalanceComponent", "financial", element.getFinancial().get(i), i);
10997    }
10998  }
10999
11000  protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) {
11001    if (element == null) 
11002      return;
11003    Complex t;
11004    if (Utilities.noString(parentType))
11005      t = parent;
11006    else {
11007      t = parent.predicate("fhir:"+parentType+'.'+name);
11008    }
11009    composeBackboneElement(t, "financial", name, element, index);
11010    if (element.hasType()) {
11011      composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1);
11012    }
11013    if (element.hasAllowed()) {
11014      composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1);
11015    }
11016    if (element.hasUsed()) {
11017      composeType(t, "BenefitComponent", "used", element.getUsed(), -1);
11018    }
11019  }
11020
11021  protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) {
11022    if (element == null) 
11023      return;
11024    Complex t;
11025    if (Utilities.noString(parentType))
11026      t = parent;
11027    else {
11028      t = parent.predicate("fhir:"+parentType+'.'+name);
11029    }
11030    composeDomainResource(t, "FamilyMemberHistory", name, element, index);
11031    for (int i = 0; i < element.getIdentifier().size(); i++) {
11032      composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i);
11033    }
11034    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
11035      composeCanonical(t, "FamilyMemberHistory", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
11036    }
11037    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
11038      composeUri(t, "FamilyMemberHistory", "instantiatesUri", element.getInstantiatesUri().get(i), i);
11039    }
11040    if (element.hasStatusElement()) {
11041      composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1);
11042    }
11043    if (element.hasDataAbsentReason()) {
11044      composeCodeableConcept(t, "FamilyMemberHistory", "dataAbsentReason", element.getDataAbsentReason(), -1);
11045    }
11046    if (element.hasPatient()) {
11047      composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1);
11048    }
11049    if (element.hasDateElement()) {
11050      composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1);
11051    }
11052    if (element.hasNameElement()) {
11053      composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1);
11054    }
11055    if (element.hasRelationship()) {
11056      composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1);
11057    }
11058    if (element.hasSex()) {
11059      composeCodeableConcept(t, "FamilyMemberHistory", "sex", element.getSex(), -1);
11060    }
11061    if (element.hasBorn()) {
11062      composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1);
11063    }
11064    if (element.hasAge()) {
11065      composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1);
11066    }
11067    if (element.hasEstimatedAgeElement()) {
11068      composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1);
11069    }
11070    if (element.hasDeceased()) {
11071      composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1);
11072    }
11073    for (int i = 0; i < element.getReason().size(); i++) {
11074      composeCodeableReference(t, "FamilyMemberHistory", "reason", element.getReason().get(i), i);
11075    }
11076    for (int i = 0; i < element.getNote().size(); i++) {
11077      composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i);
11078    }
11079    for (int i = 0; i < element.getCondition().size(); i++) {
11080      composeFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i);
11081    }
11082    for (int i = 0; i < element.getProcedure().size(); i++) {
11083      composeFamilyMemberHistoryProcedureComponent(t, "FamilyMemberHistory", "procedure", element.getProcedure().get(i), i);
11084    }
11085  }
11086
11087  protected void composeFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) {
11088    if (element == null) 
11089      return;
11090    Complex t;
11091    if (Utilities.noString(parentType))
11092      t = parent;
11093    else {
11094      t = parent.predicate("fhir:"+parentType+'.'+name);
11095    }
11096    composeBackboneElement(t, "condition", name, element, index);
11097    if (element.hasCode()) {
11098      composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "code", element.getCode(), -1);
11099    }
11100    if (element.hasOutcome()) {
11101      composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "outcome", element.getOutcome(), -1);
11102    }
11103    if (element.hasContributedToDeathElement()) {
11104      composeBoolean(t, "FamilyMemberHistoryConditionComponent", "contributedToDeath", element.getContributedToDeathElement(), -1);
11105    }
11106    if (element.hasOnset()) {
11107      composeType(t, "FamilyMemberHistoryConditionComponent", "onset", element.getOnset(), -1);
11108    }
11109    for (int i = 0; i < element.getNote().size(); i++) {
11110      composeAnnotation(t, "FamilyMemberHistoryConditionComponent", "note", element.getNote().get(i), i);
11111    }
11112  }
11113
11114  protected void composeFamilyMemberHistoryProcedureComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryProcedureComponent element, int index) {
11115    if (element == null) 
11116      return;
11117    Complex t;
11118    if (Utilities.noString(parentType))
11119      t = parent;
11120    else {
11121      t = parent.predicate("fhir:"+parentType+'.'+name);
11122    }
11123    composeBackboneElement(t, "procedure", name, element, index);
11124    if (element.hasCode()) {
11125      composeCodeableConcept(t, "FamilyMemberHistoryProcedureComponent", "code", element.getCode(), -1);
11126    }
11127    if (element.hasOutcome()) {
11128      composeCodeableConcept(t, "FamilyMemberHistoryProcedureComponent", "outcome", element.getOutcome(), -1);
11129    }
11130    if (element.hasContributedToDeathElement()) {
11131      composeBoolean(t, "FamilyMemberHistoryProcedureComponent", "contributedToDeath", element.getContributedToDeathElement(), -1);
11132    }
11133    if (element.hasPerformed()) {
11134      composeType(t, "FamilyMemberHistoryProcedureComponent", "performed", element.getPerformed(), -1);
11135    }
11136    for (int i = 0; i < element.getNote().size(); i++) {
11137      composeAnnotation(t, "FamilyMemberHistoryProcedureComponent", "note", element.getNote().get(i), i);
11138    }
11139  }
11140
11141  protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) {
11142    if (element == null) 
11143      return;
11144    Complex t;
11145    if (Utilities.noString(parentType))
11146      t = parent;
11147    else {
11148      t = parent.predicate("fhir:"+parentType+'.'+name);
11149    }
11150    composeDomainResource(t, "Flag", name, element, index);
11151    for (int i = 0; i < element.getIdentifier().size(); i++) {
11152      composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i);
11153    }
11154    if (element.hasStatusElement()) {
11155      composeEnum(t, "Flag", "status", element.getStatusElement(), -1);
11156    }
11157    for (int i = 0; i < element.getCategory().size(); i++) {
11158      composeCodeableConcept(t, "Flag", "category", element.getCategory().get(i), i);
11159    }
11160    if (element.hasCode()) {
11161      composeCodeableConcept(t, "Flag", "code", element.getCode(), -1);
11162    }
11163    if (element.hasSubject()) {
11164      composeReference(t, "Flag", "subject", element.getSubject(), -1);
11165    }
11166    if (element.hasPeriod()) {
11167      composePeriod(t, "Flag", "period", element.getPeriod(), -1);
11168    }
11169    if (element.hasEncounter()) {
11170      composeReference(t, "Flag", "encounter", element.getEncounter(), -1);
11171    }
11172    if (element.hasAuthor()) {
11173      composeReference(t, "Flag", "author", element.getAuthor(), -1);
11174    }
11175  }
11176
11177  protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) {
11178    if (element == null) 
11179      return;
11180    Complex t;
11181    if (Utilities.noString(parentType))
11182      t = parent;
11183    else {
11184      t = parent.predicate("fhir:"+parentType+'.'+name);
11185    }
11186    composeDomainResource(t, "Goal", name, element, index);
11187    for (int i = 0; i < element.getIdentifier().size(); i++) {
11188      composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i);
11189    }
11190    if (element.hasLifecycleStatusElement()) {
11191      composeEnum(t, "Goal", "lifecycleStatus", element.getLifecycleStatusElement(), -1);
11192    }
11193    if (element.hasAchievementStatus()) {
11194      composeCodeableConcept(t, "Goal", "achievementStatus", element.getAchievementStatus(), -1);
11195    }
11196    for (int i = 0; i < element.getCategory().size(); i++) {
11197      composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i);
11198    }
11199    if (element.hasContinuousElement()) {
11200      composeBoolean(t, "Goal", "continuous", element.getContinuousElement(), -1);
11201    }
11202    if (element.hasPriority()) {
11203      composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1);
11204    }
11205    if (element.hasDescription()) {
11206      composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1);
11207    }
11208    if (element.hasSubject()) {
11209      composeReference(t, "Goal", "subject", element.getSubject(), -1);
11210    }
11211    if (element.hasStart()) {
11212      composeType(t, "Goal", "start", element.getStart(), -1);
11213    }
11214    for (int i = 0; i < element.getTarget().size(); i++) {
11215      composeGoalTargetComponent(t, "Goal", "target", element.getTarget().get(i), i);
11216    }
11217    if (element.hasStatusDateElement()) {
11218      composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1);
11219    }
11220    if (element.hasStatusReasonElement()) {
11221      composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1);
11222    }
11223    if (element.hasExpressedBy()) {
11224      composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1);
11225    }
11226    for (int i = 0; i < element.getAddresses().size(); i++) {
11227      composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i);
11228    }
11229    for (int i = 0; i < element.getNote().size(); i++) {
11230      composeAnnotation(t, "Goal", "note", element.getNote().get(i), i);
11231    }
11232    for (int i = 0; i < element.getOutcome().size(); i++) {
11233      composeCodeableReference(t, "Goal", "outcome", element.getOutcome().get(i), i);
11234    }
11235  }
11236
11237  protected void composeGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) {
11238    if (element == null) 
11239      return;
11240    Complex t;
11241    if (Utilities.noString(parentType))
11242      t = parent;
11243    else {
11244      t = parent.predicate("fhir:"+parentType+'.'+name);
11245    }
11246    composeBackboneElement(t, "target", name, element, index);
11247    if (element.hasMeasure()) {
11248      composeCodeableConcept(t, "GoalTargetComponent", "measure", element.getMeasure(), -1);
11249    }
11250    if (element.hasDetail()) {
11251      composeType(t, "GoalTargetComponent", "detail", element.getDetail(), -1);
11252    }
11253    if (element.hasDue()) {
11254      composeType(t, "GoalTargetComponent", "due", element.getDue(), -1);
11255    }
11256  }
11257
11258  protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) {
11259    if (element == null) 
11260      return;
11261    Complex t;
11262    if (Utilities.noString(parentType))
11263      t = parent;
11264    else {
11265      t = parent.predicate("fhir:"+parentType+'.'+name);
11266    }
11267    composeCanonicalResource(t, "GraphDefinition", name, element, index);
11268    if (element.hasUrlElement()) {
11269      composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1);
11270    }
11271    if (element.hasVersionElement()) {
11272      composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1);
11273    }
11274    if (element.hasNameElement()) {
11275      composeString(t, "GraphDefinition", "name", element.getNameElement(), -1);
11276    }
11277    if (element.hasStatusElement()) {
11278      composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1);
11279    }
11280    if (element.hasExperimentalElement()) {
11281      composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1);
11282    }
11283    if (element.hasDateElement()) {
11284      composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1);
11285    }
11286    if (element.hasPublisherElement()) {
11287      composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1);
11288    }
11289    for (int i = 0; i < element.getContact().size(); i++) {
11290      composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i);
11291    }
11292    if (element.hasDescriptionElement()) {
11293      composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1);
11294    }
11295    for (int i = 0; i < element.getUseContext().size(); i++) {
11296      composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i);
11297    }
11298    for (int i = 0; i < element.getJurisdiction().size(); i++) {
11299      composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
11300    }
11301    if (element.hasPurposeElement()) {
11302      composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1);
11303    }
11304    if (element.hasStartElement()) {
11305      composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1);
11306    }
11307    if (element.hasProfileElement()) {
11308      composeCanonical(t, "GraphDefinition", "profile", element.getProfileElement(), -1);
11309    }
11310    for (int i = 0; i < element.getLink().size(); i++) {
11311      composeGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i);
11312    }
11313  }
11314
11315  protected void composeGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) {
11316    if (element == null) 
11317      return;
11318    Complex t;
11319    if (Utilities.noString(parentType))
11320      t = parent;
11321    else {
11322      t = parent.predicate("fhir:"+parentType+'.'+name);
11323    }
11324    composeBackboneElement(t, "link", name, element, index);
11325    if (element.hasPathElement()) {
11326      composeString(t, "GraphDefinitionLinkComponent", "path", element.getPathElement(), -1);
11327    }
11328    if (element.hasSliceNameElement()) {
11329      composeString(t, "GraphDefinitionLinkComponent", "sliceName", element.getSliceNameElement(), -1);
11330    }
11331    if (element.hasMinElement()) {
11332      composeInteger(t, "GraphDefinitionLinkComponent", "min", element.getMinElement(), -1);
11333    }
11334    if (element.hasMaxElement()) {
11335      composeString(t, "GraphDefinitionLinkComponent", "max", element.getMaxElement(), -1);
11336    }
11337    if (element.hasDescriptionElement()) {
11338      composeString(t, "GraphDefinitionLinkComponent", "description", element.getDescriptionElement(), -1);
11339    }
11340    for (int i = 0; i < element.getTarget().size(); i++) {
11341      composeGraphDefinitionLinkTargetComponent(t, "GraphDefinitionLinkComponent", "target", element.getTarget().get(i), i);
11342    }
11343  }
11344
11345  protected void composeGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) {
11346    if (element == null) 
11347      return;
11348    Complex t;
11349    if (Utilities.noString(parentType))
11350      t = parent;
11351    else {
11352      t = parent.predicate("fhir:"+parentType+'.'+name);
11353    }
11354    composeBackboneElement(t, "target", name, element, index);
11355    if (element.hasTypeElement()) {
11356      composeCode(t, "GraphDefinitionLinkTargetComponent", "type", element.getTypeElement(), -1);
11357    }
11358    if (element.hasParamsElement()) {
11359      composeString(t, "GraphDefinitionLinkTargetComponent", "params", element.getParamsElement(), -1);
11360    }
11361    if (element.hasProfileElement()) {
11362      composeCanonical(t, "GraphDefinitionLinkTargetComponent", "profile", element.getProfileElement(), -1);
11363    }
11364    for (int i = 0; i < element.getCompartment().size(); i++) {
11365      composeGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinitionLinkTargetComponent", "compartment", element.getCompartment().get(i), i);
11366    }
11367    for (int i = 0; i < element.getLink().size(); i++) {
11368      composeGraphDefinitionLinkComponent(t, "GraphDefinitionLinkTargetComponent", "link", element.getLink().get(i), i);
11369    }
11370  }
11371
11372  protected void composeGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) {
11373    if (element == null) 
11374      return;
11375    Complex t;
11376    if (Utilities.noString(parentType))
11377      t = parent;
11378    else {
11379      t = parent.predicate("fhir:"+parentType+'.'+name);
11380    }
11381    composeBackboneElement(t, "compartment", name, element, index);
11382    if (element.hasUseElement()) {
11383      composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "use", element.getUseElement(), -1);
11384    }
11385    if (element.hasCodeElement()) {
11386      composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "code", element.getCodeElement(), -1);
11387    }
11388    if (element.hasRuleElement()) {
11389      composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "rule", element.getRuleElement(), -1);
11390    }
11391    if (element.hasExpressionElement()) {
11392      composeString(t, "GraphDefinitionLinkTargetCompartmentComponent", "expression", element.getExpressionElement(), -1);
11393    }
11394    if (element.hasDescriptionElement()) {
11395      composeString(t, "GraphDefinitionLinkTargetCompartmentComponent", "description", element.getDescriptionElement(), -1);
11396    }
11397  }
11398
11399  protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) {
11400    if (element == null) 
11401      return;
11402    Complex t;
11403    if (Utilities.noString(parentType))
11404      t = parent;
11405    else {
11406      t = parent.predicate("fhir:"+parentType+'.'+name);
11407    }
11408    composeDomainResource(t, "Group", name, element, index);
11409    for (int i = 0; i < element.getIdentifier().size(); i++) {
11410      composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i);
11411    }
11412    if (element.hasActiveElement()) {
11413      composeBoolean(t, "Group", "active", element.getActiveElement(), -1);
11414    }
11415    if (element.hasTypeElement()) {
11416      composeEnum(t, "Group", "type", element.getTypeElement(), -1);
11417    }
11418    if (element.hasActualElement()) {
11419      composeBoolean(t, "Group", "actual", element.getActualElement(), -1);
11420    }
11421    if (element.hasCode()) {
11422      composeCodeableConcept(t, "Group", "code", element.getCode(), -1);
11423    }
11424    if (element.hasNameElement()) {
11425      composeString(t, "Group", "name", element.getNameElement(), -1);
11426    }
11427    if (element.hasQuantityElement()) {
11428      composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1);
11429    }
11430    if (element.hasManagingEntity()) {
11431      composeReference(t, "Group", "managingEntity", element.getManagingEntity(), -1);
11432    }
11433    for (int i = 0; i < element.getCharacteristic().size(); i++) {
11434      composeGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i);
11435    }
11436    for (int i = 0; i < element.getMember().size(); i++) {
11437      composeGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i);
11438    }
11439  }
11440
11441  protected void composeGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) {
11442    if (element == null) 
11443      return;
11444    Complex t;
11445    if (Utilities.noString(parentType))
11446      t = parent;
11447    else {
11448      t = parent.predicate("fhir:"+parentType+'.'+name);
11449    }
11450    composeBackboneElement(t, "characteristic", name, element, index);
11451    if (element.hasCode()) {
11452      composeCodeableConcept(t, "GroupCharacteristicComponent", "code", element.getCode(), -1);
11453    }
11454    if (element.hasValue()) {
11455      composeType(t, "GroupCharacteristicComponent", "value", element.getValue(), -1);
11456    }
11457    if (element.hasExcludeElement()) {
11458      composeBoolean(t, "GroupCharacteristicComponent", "exclude", element.getExcludeElement(), -1);
11459    }
11460    if (element.hasPeriod()) {
11461      composePeriod(t, "GroupCharacteristicComponent", "period", element.getPeriod(), -1);
11462    }
11463  }
11464
11465  protected void composeGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) {
11466    if (element == null) 
11467      return;
11468    Complex t;
11469    if (Utilities.noString(parentType))
11470      t = parent;
11471    else {
11472      t = parent.predicate("fhir:"+parentType+'.'+name);
11473    }
11474    composeBackboneElement(t, "member", name, element, index);
11475    if (element.hasEntity()) {
11476      composeReference(t, "GroupMemberComponent", "entity", element.getEntity(), -1);
11477    }
11478    if (element.hasPeriod()) {
11479      composePeriod(t, "GroupMemberComponent", "period", element.getPeriod(), -1);
11480    }
11481    if (element.hasInactiveElement()) {
11482      composeBoolean(t, "GroupMemberComponent", "inactive", element.getInactiveElement(), -1);
11483    }
11484  }
11485
11486  protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse 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    composeDomainResource(t, "GuidanceResponse", name, element, index);
11496    if (element.hasRequestIdentifier()) {
11497      composeIdentifier(t, "GuidanceResponse", "requestIdentifier", element.getRequestIdentifier(), -1);
11498    }
11499    for (int i = 0; i < element.getIdentifier().size(); i++) {
11500      composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier().get(i), i);
11501    }
11502    if (element.hasModule()) {
11503      composeType(t, "GuidanceResponse", "module", element.getModule(), -1);
11504    }
11505    if (element.hasStatusElement()) {
11506      composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1);
11507    }
11508    if (element.hasSubject()) {
11509      composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1);
11510    }
11511    if (element.hasEncounter()) {
11512      composeReference(t, "GuidanceResponse", "encounter", element.getEncounter(), -1);
11513    }
11514    if (element.hasOccurrenceDateTimeElement()) {
11515      composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1);
11516    }
11517    if (element.hasPerformer()) {
11518      composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1);
11519    }
11520    for (int i = 0; i < element.getReason().size(); i++) {
11521      composeCodeableReference(t, "GuidanceResponse", "reason", element.getReason().get(i), i);
11522    }
11523    for (int i = 0; i < element.getNote().size(); i++) {
11524      composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i);
11525    }
11526    for (int i = 0; i < element.getEvaluationMessage().size(); i++) {
11527      composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i);
11528    }
11529    if (element.hasOutputParameters()) {
11530      composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1);
11531    }
11532    if (element.hasResult()) {
11533      composeReference(t, "GuidanceResponse", "result", element.getResult(), -1);
11534    }
11535    for (int i = 0; i < element.getDataRequirement().size(); i++) {
11536      composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i);
11537    }
11538  }
11539
11540  protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) {
11541    if (element == null) 
11542      return;
11543    Complex t;
11544    if (Utilities.noString(parentType))
11545      t = parent;
11546    else {
11547      t = parent.predicate("fhir:"+parentType+'.'+name);
11548    }
11549    composeDomainResource(t, "HealthcareService", name, element, index);
11550    for (int i = 0; i < element.getIdentifier().size(); i++) {
11551      composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i);
11552    }
11553    if (element.hasActiveElement()) {
11554      composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1);
11555    }
11556    if (element.hasProvidedBy()) {
11557      composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1);
11558    }
11559    for (int i = 0; i < element.getCategory().size(); i++) {
11560      composeCodeableConcept(t, "HealthcareService", "category", element.getCategory().get(i), i);
11561    }
11562    for (int i = 0; i < element.getType().size(); i++) {
11563      composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i);
11564    }
11565    for (int i = 0; i < element.getSpecialty().size(); i++) {
11566      composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i);
11567    }
11568    for (int i = 0; i < element.getLocation().size(); i++) {
11569      composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i);
11570    }
11571    if (element.hasNameElement()) {
11572      composeString(t, "HealthcareService", "name", element.getNameElement(), -1);
11573    }
11574    if (element.hasCommentElement()) {
11575      composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1);
11576    }
11577    if (element.hasExtraDetailsElement()) {
11578      composeMarkdown(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1);
11579    }
11580    if (element.hasPhoto()) {
11581      composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1);
11582    }
11583    for (int i = 0; i < element.getTelecom().size(); i++) {
11584      composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i);
11585    }
11586    for (int i = 0; i < element.getCoverageArea().size(); i++) {
11587      composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i);
11588    }
11589    for (int i = 0; i < element.getServiceProvisionCode().size(); i++) {
11590      composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i);
11591    }
11592    for (int i = 0; i < element.getEligibility().size(); i++) {
11593      composeHealthcareServiceEligibilityComponent(t, "HealthcareService", "eligibility", element.getEligibility().get(i), i);
11594    }
11595    for (int i = 0; i < element.getProgram().size(); i++) {
11596      composeCodeableConcept(t, "HealthcareService", "program", element.getProgram().get(i), i);
11597    }
11598    for (int i = 0; i < element.getCharacteristic().size(); i++) {
11599      composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i);
11600    }
11601    for (int i = 0; i < element.getCommunication().size(); i++) {
11602      composeCodeableConcept(t, "HealthcareService", "communication", element.getCommunication().get(i), i);
11603    }
11604    for (int i = 0; i < element.getReferralMethod().size(); i++) {
11605      composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i);
11606    }
11607    if (element.hasAppointmentRequiredElement()) {
11608      composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1);
11609    }
11610    for (int i = 0; i < element.getAvailableTime().size(); i++) {
11611      composeHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i);
11612    }
11613    for (int i = 0; i < element.getNotAvailable().size(); i++) {
11614      composeHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i);
11615    }
11616    if (element.hasAvailabilityExceptionsElement()) {
11617      composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
11618    }
11619    for (int i = 0; i < element.getEndpoint().size(); i++) {
11620      composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i);
11621    }
11622  }
11623
11624  protected void composeHealthcareServiceEligibilityComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceEligibilityComponent element, int index) {
11625    if (element == null) 
11626      return;
11627    Complex t;
11628    if (Utilities.noString(parentType))
11629      t = parent;
11630    else {
11631      t = parent.predicate("fhir:"+parentType+'.'+name);
11632    }
11633    composeBackboneElement(t, "eligibility", name, element, index);
11634    if (element.hasCode()) {
11635      composeCodeableConcept(t, "HealthcareServiceEligibilityComponent", "code", element.getCode(), -1);
11636    }
11637    if (element.hasCommentElement()) {
11638      composeMarkdown(t, "HealthcareServiceEligibilityComponent", "comment", element.getCommentElement(), -1);
11639    }
11640  }
11641
11642  protected void composeHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) {
11643    if (element == null) 
11644      return;
11645    Complex t;
11646    if (Utilities.noString(parentType))
11647      t = parent;
11648    else {
11649      t = parent.predicate("fhir:"+parentType+'.'+name);
11650    }
11651    composeBackboneElement(t, "availableTime", name, element, index);
11652    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
11653      composeEnum(t, "HealthcareServiceAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
11654    }
11655    if (element.hasAllDayElement()) {
11656      composeBoolean(t, "HealthcareServiceAvailableTimeComponent", "allDay", element.getAllDayElement(), -1);
11657    }
11658    if (element.hasAvailableStartTimeElement()) {
11659      composeTime(t, "HealthcareServiceAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1);
11660    }
11661    if (element.hasAvailableEndTimeElement()) {
11662      composeTime(t, "HealthcareServiceAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1);
11663    }
11664  }
11665
11666  protected void composeHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) {
11667    if (element == null) 
11668      return;
11669    Complex t;
11670    if (Utilities.noString(parentType))
11671      t = parent;
11672    else {
11673      t = parent.predicate("fhir:"+parentType+'.'+name);
11674    }
11675    composeBackboneElement(t, "notAvailable", name, element, index);
11676    if (element.hasDescriptionElement()) {
11677      composeString(t, "HealthcareServiceNotAvailableComponent", "description", element.getDescriptionElement(), -1);
11678    }
11679    if (element.hasDuring()) {
11680      composePeriod(t, "HealthcareServiceNotAvailableComponent", "during", element.getDuring(), -1);
11681    }
11682  }
11683
11684  protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) {
11685    if (element == null) 
11686      return;
11687    Complex t;
11688    if (Utilities.noString(parentType))
11689      t = parent;
11690    else {
11691      t = parent.predicate("fhir:"+parentType+'.'+name);
11692    }
11693    composeDomainResource(t, "ImagingStudy", name, element, index);
11694    for (int i = 0; i < element.getIdentifier().size(); i++) {
11695      composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i);
11696    }
11697    if (element.hasStatusElement()) {
11698      composeEnum(t, "ImagingStudy", "status", element.getStatusElement(), -1);
11699    }
11700    for (int i = 0; i < element.getModality().size(); i++) {
11701      composeCoding(t, "ImagingStudy", "modality", element.getModality().get(i), i);
11702    }
11703    if (element.hasSubject()) {
11704      composeReference(t, "ImagingStudy", "subject", element.getSubject(), -1);
11705    }
11706    if (element.hasEncounter()) {
11707      composeReference(t, "ImagingStudy", "encounter", element.getEncounter(), -1);
11708    }
11709    if (element.hasStartedElement()) {
11710      composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1);
11711    }
11712    for (int i = 0; i < element.getBasedOn().size(); i++) {
11713      composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i);
11714    }
11715    if (element.hasReferrer()) {
11716      composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1);
11717    }
11718    for (int i = 0; i < element.getInterpreter().size(); i++) {
11719      composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i);
11720    }
11721    for (int i = 0; i < element.getEndpoint().size(); i++) {
11722      composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i);
11723    }
11724    if (element.hasNumberOfSeriesElement()) {
11725      composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1);
11726    }
11727    if (element.hasNumberOfInstancesElement()) {
11728      composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
11729    }
11730    for (int i = 0; i < element.getProcedure().size(); i++) {
11731      composeImagingStudyProcedureComponent(t, "ImagingStudy", "procedure", element.getProcedure().get(i), i);
11732    }
11733    if (element.hasLocation()) {
11734      composeReference(t, "ImagingStudy", "location", element.getLocation(), -1);
11735    }
11736    for (int i = 0; i < element.getReason().size(); i++) {
11737      composeCodeableReference(t, "ImagingStudy", "reason", element.getReason().get(i), i);
11738    }
11739    for (int i = 0; i < element.getNote().size(); i++) {
11740      composeAnnotation(t, "ImagingStudy", "note", element.getNote().get(i), i);
11741    }
11742    if (element.hasDescriptionElement()) {
11743      composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1);
11744    }
11745    for (int i = 0; i < element.getSeries().size(); i++) {
11746      composeImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i);
11747    }
11748  }
11749
11750  protected void composeImagingStudyProcedureComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudyProcedureComponent element, int index) {
11751    if (element == null) 
11752      return;
11753    Complex t;
11754    if (Utilities.noString(parentType))
11755      t = parent;
11756    else {
11757      t = parent.predicate("fhir:"+parentType+'.'+name);
11758    }
11759    composeBackboneElement(t, "procedure", name, element, index);
11760    if (element.hasValue()) {
11761      composeType(t, "ImagingStudyProcedureComponent", "value", element.getValue(), -1);
11762    }
11763  }
11764
11765  protected void composeImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) {
11766    if (element == null) 
11767      return;
11768    Complex t;
11769    if (Utilities.noString(parentType))
11770      t = parent;
11771    else {
11772      t = parent.predicate("fhir:"+parentType+'.'+name);
11773    }
11774    composeBackboneElement(t, "series", name, element, index);
11775    if (element.hasUidElement()) {
11776      composeId(t, "ImagingStudySeriesComponent", "uid", element.getUidElement(), -1);
11777    }
11778    if (element.hasNumberElement()) {
11779      composeUnsignedInt(t, "ImagingStudySeriesComponent", "number", element.getNumberElement(), -1);
11780    }
11781    if (element.hasModality()) {
11782      composeCoding(t, "ImagingStudySeriesComponent", "modality", element.getModality(), -1);
11783    }
11784    if (element.hasDescriptionElement()) {
11785      composeString(t, "ImagingStudySeriesComponent", "description", element.getDescriptionElement(), -1);
11786    }
11787    if (element.hasNumberOfInstancesElement()) {
11788      composeUnsignedInt(t, "ImagingStudySeriesComponent", "numberOfInstances", element.getNumberOfInstancesElement(), -1);
11789    }
11790    for (int i = 0; i < element.getEndpoint().size(); i++) {
11791      composeReference(t, "ImagingStudySeriesComponent", "endpoint", element.getEndpoint().get(i), i);
11792    }
11793    if (element.hasBodySite()) {
11794      composeCoding(t, "ImagingStudySeriesComponent", "bodySite", element.getBodySite(), -1);
11795    }
11796    if (element.hasLaterality()) {
11797      composeCoding(t, "ImagingStudySeriesComponent", "laterality", element.getLaterality(), -1);
11798    }
11799    for (int i = 0; i < element.getSpecimen().size(); i++) {
11800      composeReference(t, "ImagingStudySeriesComponent", "specimen", element.getSpecimen().get(i), i);
11801    }
11802    if (element.hasStartedElement()) {
11803      composeDateTime(t, "ImagingStudySeriesComponent", "started", element.getStartedElement(), -1);
11804    }
11805    for (int i = 0; i < element.getPerformer().size(); i++) {
11806      composeImagingStudySeriesPerformerComponent(t, "ImagingStudySeriesComponent", "performer", element.getPerformer().get(i), i);
11807    }
11808    for (int i = 0; i < element.getInstance().size(); i++) {
11809      composeImagingStudySeriesInstanceComponent(t, "ImagingStudySeriesComponent", "instance", element.getInstance().get(i), i);
11810    }
11811  }
11812
11813  protected void composeImagingStudySeriesPerformerComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesPerformerComponent element, int index) {
11814    if (element == null) 
11815      return;
11816    Complex t;
11817    if (Utilities.noString(parentType))
11818      t = parent;
11819    else {
11820      t = parent.predicate("fhir:"+parentType+'.'+name);
11821    }
11822    composeBackboneElement(t, "performer", name, element, index);
11823    if (element.hasFunction()) {
11824      composeCodeableConcept(t, "ImagingStudySeriesPerformerComponent", "function", element.getFunction(), -1);
11825    }
11826    if (element.hasActor()) {
11827      composeReference(t, "ImagingStudySeriesPerformerComponent", "actor", element.getActor(), -1);
11828    }
11829  }
11830
11831  protected void composeImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) {
11832    if (element == null) 
11833      return;
11834    Complex t;
11835    if (Utilities.noString(parentType))
11836      t = parent;
11837    else {
11838      t = parent.predicate("fhir:"+parentType+'.'+name);
11839    }
11840    composeBackboneElement(t, "instance", name, element, index);
11841    if (element.hasUidElement()) {
11842      composeId(t, "ImagingStudySeriesInstanceComponent", "uid", element.getUidElement(), -1);
11843    }
11844    if (element.hasSopClass()) {
11845      composeCoding(t, "ImagingStudySeriesInstanceComponent", "sopClass", element.getSopClass(), -1);
11846    }
11847    if (element.hasNumberElement()) {
11848      composeUnsignedInt(t, "ImagingStudySeriesInstanceComponent", "number", element.getNumberElement(), -1);
11849    }
11850    if (element.hasTitleElement()) {
11851      composeString(t, "ImagingStudySeriesInstanceComponent", "title", element.getTitleElement(), -1);
11852    }
11853  }
11854
11855  protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) {
11856    if (element == null) 
11857      return;
11858    Complex t;
11859    if (Utilities.noString(parentType))
11860      t = parent;
11861    else {
11862      t = parent.predicate("fhir:"+parentType+'.'+name);
11863    }
11864    composeDomainResource(t, "Immunization", name, element, index);
11865    for (int i = 0; i < element.getIdentifier().size(); i++) {
11866      composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i);
11867    }
11868    if (element.hasStatusElement()) {
11869      composeEnum(t, "Immunization", "status", element.getStatusElement(), -1);
11870    }
11871    if (element.hasStatusReason()) {
11872      composeCodeableConcept(t, "Immunization", "statusReason", element.getStatusReason(), -1);
11873    }
11874    if (element.hasVaccineCode()) {
11875      composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1);
11876    }
11877    if (element.hasPatient()) {
11878      composeReference(t, "Immunization", "patient", element.getPatient(), -1);
11879    }
11880    if (element.hasEncounter()) {
11881      composeReference(t, "Immunization", "encounter", element.getEncounter(), -1);
11882    }
11883    if (element.hasOccurrence()) {
11884      composeType(t, "Immunization", "occurrence", element.getOccurrence(), -1);
11885    }
11886    if (element.hasRecordedElement()) {
11887      composeDateTime(t, "Immunization", "recorded", element.getRecordedElement(), -1);
11888    }
11889    if (element.hasPrimarySourceElement()) {
11890      composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1);
11891    }
11892    if (element.hasInformationSource()) {
11893      composeType(t, "Immunization", "informationSource", element.getInformationSource(), -1);
11894    }
11895    if (element.hasLocation()) {
11896      composeReference(t, "Immunization", "location", element.getLocation(), -1);
11897    }
11898    if (element.hasManufacturer()) {
11899      composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1);
11900    }
11901    if (element.hasLotNumberElement()) {
11902      composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1);
11903    }
11904    if (element.hasExpirationDateElement()) {
11905      composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1);
11906    }
11907    if (element.hasSite()) {
11908      composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1);
11909    }
11910    if (element.hasRoute()) {
11911      composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1);
11912    }
11913    if (element.hasDoseQuantity()) {
11914      composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1);
11915    }
11916    for (int i = 0; i < element.getPerformer().size(); i++) {
11917      composeImmunizationPerformerComponent(t, "Immunization", "performer", element.getPerformer().get(i), i);
11918    }
11919    for (int i = 0; i < element.getNote().size(); i++) {
11920      composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i);
11921    }
11922    for (int i = 0; i < element.getReason().size(); i++) {
11923      composeCodeableReference(t, "Immunization", "reason", element.getReason().get(i), i);
11924    }
11925    if (element.hasIsSubpotentElement()) {
11926      composeBoolean(t, "Immunization", "isSubpotent", element.getIsSubpotentElement(), -1);
11927    }
11928    for (int i = 0; i < element.getSubpotentReason().size(); i++) {
11929      composeCodeableConcept(t, "Immunization", "subpotentReason", element.getSubpotentReason().get(i), i);
11930    }
11931    for (int i = 0; i < element.getEducation().size(); i++) {
11932      composeImmunizationEducationComponent(t, "Immunization", "education", element.getEducation().get(i), i);
11933    }
11934    for (int i = 0; i < element.getProgramEligibility().size(); i++) {
11935      composeCodeableConcept(t, "Immunization", "programEligibility", element.getProgramEligibility().get(i), i);
11936    }
11937    if (element.hasFundingSource()) {
11938      composeCodeableConcept(t, "Immunization", "fundingSource", element.getFundingSource(), -1);
11939    }
11940    for (int i = 0; i < element.getReaction().size(); i++) {
11941      composeImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i);
11942    }
11943    for (int i = 0; i < element.getProtocolApplied().size(); i++) {
11944      composeImmunizationProtocolAppliedComponent(t, "Immunization", "protocolApplied", element.getProtocolApplied().get(i), i);
11945    }
11946  }
11947
11948  protected void composeImmunizationPerformerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPerformerComponent element, int index) {
11949    if (element == null) 
11950      return;
11951    Complex t;
11952    if (Utilities.noString(parentType))
11953      t = parent;
11954    else {
11955      t = parent.predicate("fhir:"+parentType+'.'+name);
11956    }
11957    composeBackboneElement(t, "performer", name, element, index);
11958    if (element.hasFunction()) {
11959      composeCodeableConcept(t, "ImmunizationPerformerComponent", "function", element.getFunction(), -1);
11960    }
11961    if (element.hasActor()) {
11962      composeReference(t, "ImmunizationPerformerComponent", "actor", element.getActor(), -1);
11963    }
11964  }
11965
11966  protected void composeImmunizationEducationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationEducationComponent element, int index) {
11967    if (element == null) 
11968      return;
11969    Complex t;
11970    if (Utilities.noString(parentType))
11971      t = parent;
11972    else {
11973      t = parent.predicate("fhir:"+parentType+'.'+name);
11974    }
11975    composeBackboneElement(t, "education", name, element, index);
11976    if (element.hasDocumentTypeElement()) {
11977      composeString(t, "ImmunizationEducationComponent", "documentType", element.getDocumentTypeElement(), -1);
11978    }
11979    if (element.hasReferenceElement()) {
11980      composeUri(t, "ImmunizationEducationComponent", "reference", element.getReferenceElement(), -1);
11981    }
11982    if (element.hasPublicationDateElement()) {
11983      composeDateTime(t, "ImmunizationEducationComponent", "publicationDate", element.getPublicationDateElement(), -1);
11984    }
11985    if (element.hasPresentationDateElement()) {
11986      composeDateTime(t, "ImmunizationEducationComponent", "presentationDate", element.getPresentationDateElement(), -1);
11987    }
11988  }
11989
11990  protected void composeImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) {
11991    if (element == null) 
11992      return;
11993    Complex t;
11994    if (Utilities.noString(parentType))
11995      t = parent;
11996    else {
11997      t = parent.predicate("fhir:"+parentType+'.'+name);
11998    }
11999    composeBackboneElement(t, "reaction", name, element, index);
12000    if (element.hasDateElement()) {
12001      composeDateTime(t, "ImmunizationReactionComponent", "date", element.getDateElement(), -1);
12002    }
12003    if (element.hasDetail()) {
12004      composeReference(t, "ImmunizationReactionComponent", "detail", element.getDetail(), -1);
12005    }
12006    if (element.hasReportedElement()) {
12007      composeBoolean(t, "ImmunizationReactionComponent", "reported", element.getReportedElement(), -1);
12008    }
12009  }
12010
12011  protected void composeImmunizationProtocolAppliedComponent(Complex parent, String parentType, String name, Immunization.ImmunizationProtocolAppliedComponent element, int index) {
12012    if (element == null) 
12013      return;
12014    Complex t;
12015    if (Utilities.noString(parentType))
12016      t = parent;
12017    else {
12018      t = parent.predicate("fhir:"+parentType+'.'+name);
12019    }
12020    composeBackboneElement(t, "protocolApplied", name, element, index);
12021    if (element.hasSeriesElement()) {
12022      composeString(t, "ImmunizationProtocolAppliedComponent", "series", element.getSeriesElement(), -1);
12023    }
12024    if (element.hasAuthority()) {
12025      composeReference(t, "ImmunizationProtocolAppliedComponent", "authority", element.getAuthority(), -1);
12026    }
12027    for (int i = 0; i < element.getTargetDisease().size(); i++) {
12028      composeCodeableConcept(t, "ImmunizationProtocolAppliedComponent", "targetDisease", element.getTargetDisease().get(i), i);
12029    }
12030    if (element.hasDoseNumber()) {
12031      composeType(t, "ImmunizationProtocolAppliedComponent", "doseNumber", element.getDoseNumber(), -1);
12032    }
12033    if (element.hasSeriesDoses()) {
12034      composeType(t, "ImmunizationProtocolAppliedComponent", "seriesDoses", element.getSeriesDoses(), -1);
12035    }
12036  }
12037
12038  protected void composeImmunizationEvaluation(Complex parent, String parentType, String name, ImmunizationEvaluation element, int index) {
12039    if (element == null) 
12040      return;
12041    Complex t;
12042    if (Utilities.noString(parentType))
12043      t = parent;
12044    else {
12045      t = parent.predicate("fhir:"+parentType+'.'+name);
12046    }
12047    composeDomainResource(t, "ImmunizationEvaluation", name, element, index);
12048    for (int i = 0; i < element.getIdentifier().size(); i++) {
12049      composeIdentifier(t, "ImmunizationEvaluation", "identifier", element.getIdentifier().get(i), i);
12050    }
12051    if (element.hasStatusElement()) {
12052      composeEnum(t, "ImmunizationEvaluation", "status", element.getStatusElement(), -1);
12053    }
12054    if (element.hasPatient()) {
12055      composeReference(t, "ImmunizationEvaluation", "patient", element.getPatient(), -1);
12056    }
12057    if (element.hasDateElement()) {
12058      composeDateTime(t, "ImmunizationEvaluation", "date", element.getDateElement(), -1);
12059    }
12060    if (element.hasAuthority()) {
12061      composeReference(t, "ImmunizationEvaluation", "authority", element.getAuthority(), -1);
12062    }
12063    if (element.hasTargetDisease()) {
12064      composeCodeableConcept(t, "ImmunizationEvaluation", "targetDisease", element.getTargetDisease(), -1);
12065    }
12066    if (element.hasImmunizationEvent()) {
12067      composeReference(t, "ImmunizationEvaluation", "immunizationEvent", element.getImmunizationEvent(), -1);
12068    }
12069    if (element.hasDoseStatus()) {
12070      composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatus", element.getDoseStatus(), -1);
12071    }
12072    for (int i = 0; i < element.getDoseStatusReason().size(); i++) {
12073      composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatusReason", element.getDoseStatusReason().get(i), i);
12074    }
12075    if (element.hasDescriptionElement()) {
12076      composeString(t, "ImmunizationEvaluation", "description", element.getDescriptionElement(), -1);
12077    }
12078    if (element.hasSeriesElement()) {
12079      composeString(t, "ImmunizationEvaluation", "series", element.getSeriesElement(), -1);
12080    }
12081    if (element.hasDoseNumber()) {
12082      composeType(t, "ImmunizationEvaluation", "doseNumber", element.getDoseNumber(), -1);
12083    }
12084    if (element.hasSeriesDoses()) {
12085      composeType(t, "ImmunizationEvaluation", "seriesDoses", element.getSeriesDoses(), -1);
12086    }
12087  }
12088
12089  protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) {
12090    if (element == null) 
12091      return;
12092    Complex t;
12093    if (Utilities.noString(parentType))
12094      t = parent;
12095    else {
12096      t = parent.predicate("fhir:"+parentType+'.'+name);
12097    }
12098    composeDomainResource(t, "ImmunizationRecommendation", name, element, index);
12099    for (int i = 0; i < element.getIdentifier().size(); i++) {
12100      composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i);
12101    }
12102    if (element.hasPatient()) {
12103      composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1);
12104    }
12105    if (element.hasDateElement()) {
12106      composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1);
12107    }
12108    if (element.hasAuthority()) {
12109      composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1);
12110    }
12111    for (int i = 0; i < element.getRecommendation().size(); i++) {
12112      composeImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i);
12113    }
12114  }
12115
12116  protected void composeImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent 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, "recommendation", name, element, index);
12126    for (int i = 0; i < element.getVaccineCode().size(); i++) {
12127      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "vaccineCode", element.getVaccineCode().get(i), i);
12128    }
12129    for (int i = 0; i < element.getTargetDisease().size(); i++) {
12130      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "targetDisease", element.getTargetDisease().get(i), i);
12131    }
12132    for (int i = 0; i < element.getContraindicatedVaccineCode().size(); i++) {
12133      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "contraindicatedVaccineCode", element.getContraindicatedVaccineCode().get(i), i);
12134    }
12135    if (element.hasForecastStatus()) {
12136      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastStatus", element.getForecastStatus(), -1);
12137    }
12138    for (int i = 0; i < element.getForecastReason().size(); i++) {
12139      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastReason", element.getForecastReason().get(i), i);
12140    }
12141    for (int i = 0; i < element.getDateCriterion().size(); i++) {
12142      composeImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendationRecommendationComponent", "dateCriterion", element.getDateCriterion().get(i), i);
12143    }
12144    if (element.hasDescriptionElement()) {
12145      composeString(t, "ImmunizationRecommendationRecommendationComponent", "description", element.getDescriptionElement(), -1);
12146    }
12147    if (element.hasSeriesElement()) {
12148      composeString(t, "ImmunizationRecommendationRecommendationComponent", "series", element.getSeriesElement(), -1);
12149    }
12150    if (element.hasDoseNumber()) {
12151      composeType(t, "ImmunizationRecommendationRecommendationComponent", "doseNumber", element.getDoseNumber(), -1);
12152    }
12153    if (element.hasSeriesDoses()) {
12154      composeType(t, "ImmunizationRecommendationRecommendationComponent", "seriesDoses", element.getSeriesDoses(), -1);
12155    }
12156    for (int i = 0; i < element.getSupportingImmunization().size(); i++) {
12157      composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingImmunization", element.getSupportingImmunization().get(i), i);
12158    }
12159    for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) {
12160      composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i);
12161    }
12162  }
12163
12164  protected void composeImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) {
12165    if (element == null) 
12166      return;
12167    Complex t;
12168    if (Utilities.noString(parentType))
12169      t = parent;
12170    else {
12171      t = parent.predicate("fhir:"+parentType+'.'+name);
12172    }
12173    composeBackboneElement(t, "dateCriterion", name, element, index);
12174    if (element.hasCode()) {
12175      composeCodeableConcept(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "code", element.getCode(), -1);
12176    }
12177    if (element.hasValueElement()) {
12178      composeDateTime(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "value", element.getValueElement(), -1);
12179    }
12180  }
12181
12182  protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) {
12183    if (element == null) 
12184      return;
12185    Complex t;
12186    if (Utilities.noString(parentType))
12187      t = parent;
12188    else {
12189      t = parent.predicate("fhir:"+parentType+'.'+name);
12190    }
12191    composeCanonicalResource(t, "ImplementationGuide", name, element, index);
12192    if (element.hasUrlElement()) {
12193      composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1);
12194    }
12195    if (element.hasVersionElement()) {
12196      composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1);
12197    }
12198    if (element.hasNameElement()) {
12199      composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1);
12200    }
12201    if (element.hasTitleElement()) {
12202      composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1);
12203    }
12204    if (element.hasStatusElement()) {
12205      composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1);
12206    }
12207    if (element.hasExperimentalElement()) {
12208      composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1);
12209    }
12210    if (element.hasDateElement()) {
12211      composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1);
12212    }
12213    if (element.hasPublisherElement()) {
12214      composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1);
12215    }
12216    for (int i = 0; i < element.getContact().size(); i++) {
12217      composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i);
12218    }
12219    if (element.hasDescriptionElement()) {
12220      composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1);
12221    }
12222    for (int i = 0; i < element.getUseContext().size(); i++) {
12223      composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i);
12224    }
12225    for (int i = 0; i < element.getJurisdiction().size(); i++) {
12226      composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i);
12227    }
12228    if (element.hasCopyrightElement()) {
12229      composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1);
12230    }
12231    if (element.hasPackageIdElement()) {
12232      composeId(t, "ImplementationGuide", "packageId", element.getPackageIdElement(), -1);
12233    }
12234    if (element.hasLicenseElement()) {
12235      composeEnum(t, "ImplementationGuide", "license", element.getLicenseElement(), -1);
12236    }
12237    for (int i = 0; i < element.getFhirVersion().size(); i++) {
12238      composeEnum(t, "ImplementationGuide", "fhirVersion", element.getFhirVersion().get(i), i);
12239    }
12240    for (int i = 0; i < element.getDependsOn().size(); i++) {
12241      composeImplementationGuideDependsOnComponent(t, "ImplementationGuide", "dependsOn", element.getDependsOn().get(i), i);
12242    }
12243    for (int i = 0; i < element.getGlobal().size(); i++) {
12244      composeImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i);
12245    }
12246    if (element.hasDefinition()) {
12247      composeImplementationGuideDefinitionComponent(t, "ImplementationGuide", "definition", element.getDefinition(), -1);
12248    }
12249    if (element.hasManifest()) {
12250      composeImplementationGuideManifestComponent(t, "ImplementationGuide", "manifest", element.getManifest(), -1);
12251    }
12252  }
12253
12254  protected void composeImplementationGuideDependsOnComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependsOnComponent element, int index) {
12255    if (element == null) 
12256      return;
12257    Complex t;
12258    if (Utilities.noString(parentType))
12259      t = parent;
12260    else {
12261      t = parent.predicate("fhir:"+parentType+'.'+name);
12262    }
12263    composeBackboneElement(t, "dependsOn", name, element, index);
12264    if (element.hasUriElement()) {
12265      composeCanonical(t, "ImplementationGuideDependsOnComponent", "uri", element.getUriElement(), -1);
12266    }
12267    if (element.hasPackageIdElement()) {
12268      composeId(t, "ImplementationGuideDependsOnComponent", "packageId", element.getPackageIdElement(), -1);
12269    }
12270    if (element.hasVersionElement()) {
12271      composeString(t, "ImplementationGuideDependsOnComponent", "version", element.getVersionElement(), -1);
12272    }
12273  }
12274
12275  protected void composeImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) {
12276    if (element == null) 
12277      return;
12278    Complex t;
12279    if (Utilities.noString(parentType))
12280      t = parent;
12281    else {
12282      t = parent.predicate("fhir:"+parentType+'.'+name);
12283    }
12284    composeBackboneElement(t, "global", name, element, index);
12285    if (element.hasTypeElement()) {
12286      composeCode(t, "ImplementationGuideGlobalComponent", "type", element.getTypeElement(), -1);
12287    }
12288    if (element.hasProfileElement()) {
12289      composeCanonical(t, "ImplementationGuideGlobalComponent", "profile", element.getProfileElement(), -1);
12290    }
12291  }
12292
12293  protected void composeImplementationGuideDefinitionComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionComponent element, int index) {
12294    if (element == null) 
12295      return;
12296    Complex t;
12297    if (Utilities.noString(parentType))
12298      t = parent;
12299    else {
12300      t = parent.predicate("fhir:"+parentType+'.'+name);
12301    }
12302    composeBackboneElement(t, "definition", name, element, index);
12303    for (int i = 0; i < element.getGrouping().size(); i++) {
12304      composeImplementationGuideDefinitionGroupingComponent(t, "ImplementationGuideDefinitionComponent", "grouping", element.getGrouping().get(i), i);
12305    }
12306    for (int i = 0; i < element.getResource().size(); i++) {
12307      composeImplementationGuideDefinitionResourceComponent(t, "ImplementationGuideDefinitionComponent", "resource", element.getResource().get(i), i);
12308    }
12309    if (element.hasPage()) {
12310      composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionComponent", "page", element.getPage(), -1);
12311    }
12312    for (int i = 0; i < element.getParameter().size(); i++) {
12313      composeImplementationGuideDefinitionParameterComponent(t, "ImplementationGuideDefinitionComponent", "parameter", element.getParameter().get(i), i);
12314    }
12315    for (int i = 0; i < element.getTemplate().size(); i++) {
12316      composeImplementationGuideDefinitionTemplateComponent(t, "ImplementationGuideDefinitionComponent", "template", element.getTemplate().get(i), i);
12317    }
12318  }
12319
12320  protected void composeImplementationGuideDefinitionGroupingComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionGroupingComponent element, int index) {
12321    if (element == null) 
12322      return;
12323    Complex t;
12324    if (Utilities.noString(parentType))
12325      t = parent;
12326    else {
12327      t = parent.predicate("fhir:"+parentType+'.'+name);
12328    }
12329    composeBackboneElement(t, "grouping", name, element, index);
12330    if (element.hasNameElement()) {
12331      composeString(t, "ImplementationGuideDefinitionGroupingComponent", "name", element.getNameElement(), -1);
12332    }
12333    if (element.hasDescriptionElement()) {
12334      composeString(t, "ImplementationGuideDefinitionGroupingComponent", "description", element.getDescriptionElement(), -1);
12335    }
12336  }
12337
12338  protected void composeImplementationGuideDefinitionResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionResourceComponent element, int index) {
12339    if (element == null) 
12340      return;
12341    Complex t;
12342    if (Utilities.noString(parentType))
12343      t = parent;
12344    else {
12345      t = parent.predicate("fhir:"+parentType+'.'+name);
12346    }
12347    composeBackboneElement(t, "resource", name, element, index);
12348    if (element.hasReference()) {
12349      composeReference(t, "ImplementationGuideDefinitionResourceComponent", "reference", element.getReference(), -1);
12350    }
12351    for (int i = 0; i < element.getFhirVersion().size(); i++) {
12352      composeEnum(t, "ImplementationGuideDefinitionResourceComponent", "fhirVersion", element.getFhirVersion().get(i), i);
12353    }
12354    if (element.hasNameElement()) {
12355      composeString(t, "ImplementationGuideDefinitionResourceComponent", "name", element.getNameElement(), -1);
12356    }
12357    if (element.hasDescriptionElement()) {
12358      composeString(t, "ImplementationGuideDefinitionResourceComponent", "description", element.getDescriptionElement(), -1);
12359    }
12360    if (element.hasExample()) {
12361      composeType(t, "ImplementationGuideDefinitionResourceComponent", "example", element.getExample(), -1);
12362    }
12363    if (element.hasGroupingIdElement()) {
12364      composeId(t, "ImplementationGuideDefinitionResourceComponent", "groupingId", element.getGroupingIdElement(), -1);
12365    }
12366  }
12367
12368  protected void composeImplementationGuideDefinitionPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionPageComponent element, int index) {
12369    if (element == null) 
12370      return;
12371    Complex t;
12372    if (Utilities.noString(parentType))
12373      t = parent;
12374    else {
12375      t = parent.predicate("fhir:"+parentType+'.'+name);
12376    }
12377    composeBackboneElement(t, "page", name, element, index);
12378    if (element.hasName()) {
12379      composeType(t, "ImplementationGuideDefinitionPageComponent", "name", element.getName(), -1);
12380    }
12381    if (element.hasTitleElement()) {
12382      composeString(t, "ImplementationGuideDefinitionPageComponent", "title", element.getTitleElement(), -1);
12383    }
12384    if (element.hasGenerationElement()) {
12385      composeEnum(t, "ImplementationGuideDefinitionPageComponent", "generation", element.getGenerationElement(), -1);
12386    }
12387    for (int i = 0; i < element.getPage().size(); i++) {
12388      composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionPageComponent", "page", element.getPage().get(i), i);
12389    }
12390  }
12391
12392  protected void composeImplementationGuideDefinitionParameterComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionParameterComponent element, int index) {
12393    if (element == null) 
12394      return;
12395    Complex t;
12396    if (Utilities.noString(parentType))
12397      t = parent;
12398    else {
12399      t = parent.predicate("fhir:"+parentType+'.'+name);
12400    }
12401    composeBackboneElement(t, "parameter", name, element, index);
12402    if (element.hasCodeElement()) {
12403      composeString(t, "ImplementationGuideDefinitionParameterComponent", "code", element.getCodeElement(), -1);
12404    }
12405    if (element.hasValueElement()) {
12406      composeString(t, "ImplementationGuideDefinitionParameterComponent", "value", element.getValueElement(), -1);
12407    }
12408  }
12409
12410  protected void composeImplementationGuideDefinitionTemplateComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionTemplateComponent element, int index) {
12411    if (element == null) 
12412      return;
12413    Complex t;
12414    if (Utilities.noString(parentType))
12415      t = parent;
12416    else {
12417      t = parent.predicate("fhir:"+parentType+'.'+name);
12418    }
12419    composeBackboneElement(t, "template", name, element, index);
12420    if (element.hasCodeElement()) {
12421      composeCode(t, "ImplementationGuideDefinitionTemplateComponent", "code", element.getCodeElement(), -1);
12422    }
12423    if (element.hasSourceElement()) {
12424      composeString(t, "ImplementationGuideDefinitionTemplateComponent", "source", element.getSourceElement(), -1);
12425    }
12426    if (element.hasScopeElement()) {
12427      composeString(t, "ImplementationGuideDefinitionTemplateComponent", "scope", element.getScopeElement(), -1);
12428    }
12429  }
12430
12431  protected void composeImplementationGuideManifestComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideManifestComponent element, int index) {
12432    if (element == null) 
12433      return;
12434    Complex t;
12435    if (Utilities.noString(parentType))
12436      t = parent;
12437    else {
12438      t = parent.predicate("fhir:"+parentType+'.'+name);
12439    }
12440    composeBackboneElement(t, "manifest", name, element, index);
12441    if (element.hasRenderingElement()) {
12442      composeUrl(t, "ImplementationGuideManifestComponent", "rendering", element.getRenderingElement(), -1);
12443    }
12444    for (int i = 0; i < element.getResource().size(); i++) {
12445      composeImplementationGuideManifestResourceComponent(t, "ImplementationGuideManifestComponent", "resource", element.getResource().get(i), i);
12446    }
12447    for (int i = 0; i < element.getPage().size(); i++) {
12448      composeImplementationGuideManifestPageComponent(t, "ImplementationGuideManifestComponent", "page", element.getPage().get(i), i);
12449    }
12450    for (int i = 0; i < element.getImage().size(); i++) {
12451      composeString(t, "ImplementationGuideManifestComponent", "image", element.getImage().get(i), i);
12452    }
12453    for (int i = 0; i < element.getOther().size(); i++) {
12454      composeString(t, "ImplementationGuideManifestComponent", "other", element.getOther().get(i), i);
12455    }
12456  }
12457
12458  protected void composeImplementationGuideManifestResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestResourceComponent element, int index) {
12459    if (element == null) 
12460      return;
12461    Complex t;
12462    if (Utilities.noString(parentType))
12463      t = parent;
12464    else {
12465      t = parent.predicate("fhir:"+parentType+'.'+name);
12466    }
12467    composeBackboneElement(t, "resource", name, element, index);
12468    if (element.hasReference()) {
12469      composeReference(t, "ManifestResourceComponent", "reference", element.getReference(), -1);
12470    }
12471    if (element.hasExample()) {
12472      composeType(t, "ManifestResourceComponent", "example", element.getExample(), -1);
12473    }
12474    if (element.hasRelativePathElement()) {
12475      composeUrl(t, "ManifestResourceComponent", "relativePath", element.getRelativePathElement(), -1);
12476    }
12477  }
12478
12479  protected void composeImplementationGuideManifestPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestPageComponent element, int index) {
12480    if (element == null) 
12481      return;
12482    Complex t;
12483    if (Utilities.noString(parentType))
12484      t = parent;
12485    else {
12486      t = parent.predicate("fhir:"+parentType+'.'+name);
12487    }
12488    composeBackboneElement(t, "page", name, element, index);
12489    if (element.hasNameElement()) {
12490      composeString(t, "ManifestPageComponent", "name", element.getNameElement(), -1);
12491    }
12492    if (element.hasTitleElement()) {
12493      composeString(t, "ManifestPageComponent", "title", element.getTitleElement(), -1);
12494    }
12495    for (int i = 0; i < element.getAnchor().size(); i++) {
12496      composeString(t, "ManifestPageComponent", "anchor", element.getAnchor().get(i), i);
12497    }
12498  }
12499
12500  protected void composeIngredient(Complex parent, String parentType, String name, Ingredient element, int index) {
12501    if (element == null) 
12502      return;
12503    Complex t;
12504    if (Utilities.noString(parentType))
12505      t = parent;
12506    else {
12507      t = parent.predicate("fhir:"+parentType+'.'+name);
12508    }
12509    composeDomainResource(t, "Ingredient", name, element, index);
12510    if (element.hasIdentifier()) {
12511      composeIdentifier(t, "Ingredient", "identifier", element.getIdentifier(), -1);
12512    }
12513    if (element.hasRole()) {
12514      composeCodeableConcept(t, "Ingredient", "role", element.getRole(), -1);
12515    }
12516    if (element.hasAllergenicIndicatorElement()) {
12517      composeBoolean(t, "Ingredient", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1);
12518    }
12519    for (int i = 0; i < element.getManufacturer().size(); i++) {
12520      composeReference(t, "Ingredient", "manufacturer", element.getManufacturer().get(i), i);
12521    }
12522    for (int i = 0; i < element.getSpecifiedSubstance().size(); i++) {
12523      composeIngredientSpecifiedSubstanceComponent(t, "Ingredient", "specifiedSubstance", element.getSpecifiedSubstance().get(i), i);
12524    }
12525    if (element.hasSubstance()) {
12526      composeIngredientSubstanceComponent(t, "Ingredient", "substance", element.getSubstance(), -1);
12527    }
12528  }
12529
12530  protected void composeIngredientSpecifiedSubstanceComponent(Complex parent, String parentType, String name, Ingredient.IngredientSpecifiedSubstanceComponent element, int index) {
12531    if (element == null) 
12532      return;
12533    Complex t;
12534    if (Utilities.noString(parentType))
12535      t = parent;
12536    else {
12537      t = parent.predicate("fhir:"+parentType+'.'+name);
12538    }
12539    composeBackboneElement(t, "specifiedSubstance", name, element, index);
12540    if (element.hasCode()) {
12541      composeType(t, "IngredientSpecifiedSubstanceComponent", "code", element.getCode(), -1);
12542    }
12543    if (element.hasGroup()) {
12544      composeCodeableConcept(t, "IngredientSpecifiedSubstanceComponent", "group", element.getGroup(), -1);
12545    }
12546    if (element.hasConfidentiality()) {
12547      composeCodeableConcept(t, "IngredientSpecifiedSubstanceComponent", "confidentiality", element.getConfidentiality(), -1);
12548    }
12549    for (int i = 0; i < element.getStrength().size(); i++) {
12550      composeIngredientSpecifiedSubstanceStrengthComponent(t, "IngredientSpecifiedSubstanceComponent", "strength", element.getStrength().get(i), i);
12551    }
12552  }
12553
12554  protected void composeIngredientSpecifiedSubstanceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSpecifiedSubstanceStrengthComponent element, int index) {
12555    if (element == null) 
12556      return;
12557    Complex t;
12558    if (Utilities.noString(parentType))
12559      t = parent;
12560    else {
12561      t = parent.predicate("fhir:"+parentType+'.'+name);
12562    }
12563    composeBackboneElement(t, "strength", name, element, index);
12564    if (element.hasPresentation()) {
12565      composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "presentation", element.getPresentation(), -1);
12566    }
12567    if (element.hasPresentationHighLimit()) {
12568      composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "presentationHighLimit", element.getPresentationHighLimit(), -1);
12569    }
12570    if (element.hasConcentration()) {
12571      composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "concentration", element.getConcentration(), -1);
12572    }
12573    if (element.hasConcentrationHighLimit()) {
12574      composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "concentrationHighLimit", element.getConcentrationHighLimit(), -1);
12575    }
12576    if (element.hasMeasurementPointElement()) {
12577      composeString(t, "IngredientSpecifiedSubstanceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1);
12578    }
12579    for (int i = 0; i < element.getCountry().size(); i++) {
12580      composeCodeableConcept(t, "IngredientSpecifiedSubstanceStrengthComponent", "country", element.getCountry().get(i), i);
12581    }
12582    for (int i = 0; i < element.getReferenceStrength().size(); i++) {
12583      composeIngredientSpecifiedSubstanceStrengthReferenceStrengthComponent(t, "IngredientSpecifiedSubstanceStrengthComponent", "referenceStrength", element.getReferenceStrength().get(i), i);
12584    }
12585  }
12586
12587  protected void composeIngredientSpecifiedSubstanceStrengthReferenceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent element, int index) {
12588    if (element == null) 
12589      return;
12590    Complex t;
12591    if (Utilities.noString(parentType))
12592      t = parent;
12593    else {
12594      t = parent.predicate("fhir:"+parentType+'.'+name);
12595    }
12596    composeBackboneElement(t, "referenceStrength", name, element, index);
12597    if (element.hasSubstance()) {
12598      composeType(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "substance", element.getSubstance(), -1);
12599    }
12600    if (element.hasStrength()) {
12601      composeRatio(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "strength", element.getStrength(), -1);
12602    }
12603    if (element.hasStrengthHighLimit()) {
12604      composeRatio(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "strengthHighLimit", element.getStrengthHighLimit(), -1);
12605    }
12606    if (element.hasMeasurementPointElement()) {
12607      composeString(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1);
12608    }
12609    for (int i = 0; i < element.getCountry().size(); i++) {
12610      composeCodeableConcept(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "country", element.getCountry().get(i), i);
12611    }
12612  }
12613
12614  protected void composeIngredientSubstanceComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceComponent element, int index) {
12615    if (element == null) 
12616      return;
12617    Complex t;
12618    if (Utilities.noString(parentType))
12619      t = parent;
12620    else {
12621      t = parent.predicate("fhir:"+parentType+'.'+name);
12622    }
12623    composeBackboneElement(t, "substance", name, element, index);
12624    if (element.hasCode()) {
12625      composeType(t, "IngredientSubstanceComponent", "code", element.getCode(), -1);
12626    }
12627    for (int i = 0; i < element.getStrength().size(); i++) {
12628      composeIngredientSpecifiedSubstanceStrengthComponent(t, "IngredientSubstanceComponent", "strength", element.getStrength().get(i), i);
12629    }
12630  }
12631
12632  protected void composeInsurancePlan(Complex parent, String parentType, String name, InsurancePlan element, int index) {
12633    if (element == null) 
12634      return;
12635    Complex t;
12636    if (Utilities.noString(parentType))
12637      t = parent;
12638    else {
12639      t = parent.predicate("fhir:"+parentType+'.'+name);
12640    }
12641    composeDomainResource(t, "InsurancePlan", name, element, index);
12642    for (int i = 0; i < element.getIdentifier().size(); i++) {
12643      composeIdentifier(t, "InsurancePlan", "identifier", element.getIdentifier().get(i), i);
12644    }
12645    if (element.hasStatusElement()) {
12646      composeEnum(t, "InsurancePlan", "status", element.getStatusElement(), -1);
12647    }
12648    for (int i = 0; i < element.getType().size(); i++) {
12649      composeCodeableConcept(t, "InsurancePlan", "type", element.getType().get(i), i);
12650    }
12651    if (element.hasNameElement()) {
12652      composeString(t, "InsurancePlan", "name", element.getNameElement(), -1);
12653    }
12654    for (int i = 0; i < element.getAlias().size(); i++) {
12655      composeString(t, "InsurancePlan", "alias", element.getAlias().get(i), i);
12656    }
12657    if (element.hasPeriod()) {
12658      composePeriod(t, "InsurancePlan", "period", element.getPeriod(), -1);
12659    }
12660    if (element.hasOwnedBy()) {
12661      composeReference(t, "InsurancePlan", "ownedBy", element.getOwnedBy(), -1);
12662    }
12663    if (element.hasAdministeredBy()) {
12664      composeReference(t, "InsurancePlan", "administeredBy", element.getAdministeredBy(), -1);
12665    }
12666    for (int i = 0; i < element.getCoverageArea().size(); i++) {
12667      composeReference(t, "InsurancePlan", "coverageArea", element.getCoverageArea().get(i), i);
12668    }
12669    for (int i = 0; i < element.getContact().size(); i++) {
12670      composeInsurancePlanContactComponent(t, "InsurancePlan", "contact", element.getContact().get(i), i);
12671    }
12672    for (int i = 0; i < element.getEndpoint().size(); i++) {
12673      composeReference(t, "InsurancePlan", "endpoint", element.getEndpoint().get(i), i);
12674    }
12675    for (int i = 0; i < element.getNetwork().size(); i++) {
12676      composeReference(t, "InsurancePlan", "network", element.getNetwork().get(i), i);
12677    }
12678    for (int i = 0; i < element.getCoverage().size(); i++) {
12679      composeInsurancePlanCoverageComponent(t, "InsurancePlan", "coverage", element.getCoverage().get(i), i);
12680    }
12681    for (int i = 0; i < element.getPlan().size(); i++) {
12682      composeInsurancePlanPlanComponent(t, "InsurancePlan", "plan", element.getPlan().get(i), i);
12683    }
12684  }
12685
12686  protected void composeInsurancePlanContactComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanContactComponent element, int index) {
12687    if (element == null) 
12688      return;
12689    Complex t;
12690    if (Utilities.noString(parentType))
12691      t = parent;
12692    else {
12693      t = parent.predicate("fhir:"+parentType+'.'+name);
12694    }
12695    composeBackboneElement(t, "contact", name, element, index);
12696    if (element.hasPurpose()) {
12697      composeCodeableConcept(t, "InsurancePlanContactComponent", "purpose", element.getPurpose(), -1);
12698    }
12699    if (element.hasName()) {
12700      composeHumanName(t, "InsurancePlanContactComponent", "name", element.getName(), -1);
12701    }
12702    for (int i = 0; i < element.getTelecom().size(); i++) {
12703      composeContactPoint(t, "InsurancePlanContactComponent", "telecom", element.getTelecom().get(i), i);
12704    }
12705    if (element.hasAddress()) {
12706      composeAddress(t, "InsurancePlanContactComponent", "address", element.getAddress(), -1);
12707    }
12708  }
12709
12710  protected void composeInsurancePlanCoverageComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanCoverageComponent element, int index) {
12711    if (element == null) 
12712      return;
12713    Complex t;
12714    if (Utilities.noString(parentType))
12715      t = parent;
12716    else {
12717      t = parent.predicate("fhir:"+parentType+'.'+name);
12718    }
12719    composeBackboneElement(t, "coverage", name, element, index);
12720    if (element.hasType()) {
12721      composeCodeableConcept(t, "InsurancePlanCoverageComponent", "type", element.getType(), -1);
12722    }
12723    for (int i = 0; i < element.getNetwork().size(); i++) {
12724      composeReference(t, "InsurancePlanCoverageComponent", "network", element.getNetwork().get(i), i);
12725    }
12726    for (int i = 0; i < element.getBenefit().size(); i++) {
12727      composeInsurancePlanCoverageBenefitComponent(t, "InsurancePlanCoverageComponent", "benefit", element.getBenefit().get(i), i);
12728    }
12729  }
12730
12731  protected void composeInsurancePlanCoverageBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitComponent element, int index) {
12732    if (element == null) 
12733      return;
12734    Complex t;
12735    if (Utilities.noString(parentType))
12736      t = parent;
12737    else {
12738      t = parent.predicate("fhir:"+parentType+'.'+name);
12739    }
12740    composeBackboneElement(t, "benefit", name, element, index);
12741    if (element.hasType()) {
12742      composeCodeableConcept(t, "CoverageBenefitComponent", "type", element.getType(), -1);
12743    }
12744    if (element.hasRequirementElement()) {
12745      composeString(t, "CoverageBenefitComponent", "requirement", element.getRequirementElement(), -1);
12746    }
12747    for (int i = 0; i < element.getLimit().size(); i++) {
12748      composeInsurancePlanCoverageBenefitLimitComponent(t, "CoverageBenefitComponent", "limit", element.getLimit().get(i), i);
12749    }
12750  }
12751
12752  protected void composeInsurancePlanCoverageBenefitLimitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitLimitComponent element, int index) {
12753    if (element == null) 
12754      return;
12755    Complex t;
12756    if (Utilities.noString(parentType))
12757      t = parent;
12758    else {
12759      t = parent.predicate("fhir:"+parentType+'.'+name);
12760    }
12761    composeBackboneElement(t, "limit", name, element, index);
12762    if (element.hasValue()) {
12763      composeQuantity(t, "CoverageBenefitLimitComponent", "value", element.getValue(), -1);
12764    }
12765    if (element.hasCode()) {
12766      composeCodeableConcept(t, "CoverageBenefitLimitComponent", "code", element.getCode(), -1);
12767    }
12768  }
12769
12770  protected void composeInsurancePlanPlanComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanComponent element, int index) {
12771    if (element == null) 
12772      return;
12773    Complex t;
12774    if (Utilities.noString(parentType))
12775      t = parent;
12776    else {
12777      t = parent.predicate("fhir:"+parentType+'.'+name);
12778    }
12779    composeBackboneElement(t, "plan", name, element, index);
12780    for (int i = 0; i < element.getIdentifier().size(); i++) {
12781      composeIdentifier(t, "InsurancePlanPlanComponent", "identifier", element.getIdentifier().get(i), i);
12782    }
12783    if (element.hasType()) {
12784      composeCodeableConcept(t, "InsurancePlanPlanComponent", "type", element.getType(), -1);
12785    }
12786    for (int i = 0; i < element.getCoverageArea().size(); i++) {
12787      composeReference(t, "InsurancePlanPlanComponent", "coverageArea", element.getCoverageArea().get(i), i);
12788    }
12789    for (int i = 0; i < element.getNetwork().size(); i++) {
12790      composeReference(t, "InsurancePlanPlanComponent", "network", element.getNetwork().get(i), i);
12791    }
12792    for (int i = 0; i < element.getGeneralCost().size(); i++) {
12793      composeInsurancePlanPlanGeneralCostComponent(t, "InsurancePlanPlanComponent", "generalCost", element.getGeneralCost().get(i), i);
12794    }
12795    for (int i = 0; i < element.getSpecificCost().size(); i++) {
12796      composeInsurancePlanPlanSpecificCostComponent(t, "InsurancePlanPlanComponent", "specificCost", element.getSpecificCost().get(i), i);
12797    }
12798  }
12799
12800  protected void composeInsurancePlanPlanGeneralCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanGeneralCostComponent element, int index) {
12801    if (element == null) 
12802      return;
12803    Complex t;
12804    if (Utilities.noString(parentType))
12805      t = parent;
12806    else {
12807      t = parent.predicate("fhir:"+parentType+'.'+name);
12808    }
12809    composeBackboneElement(t, "generalCost", name, element, index);
12810    if (element.hasType()) {
12811      composeCodeableConcept(t, "InsurancePlanPlanGeneralCostComponent", "type", element.getType(), -1);
12812    }
12813    if (element.hasGroupSizeElement()) {
12814      composePositiveInt(t, "InsurancePlanPlanGeneralCostComponent", "groupSize", element.getGroupSizeElement(), -1);
12815    }
12816    if (element.hasCost()) {
12817      composeMoney(t, "InsurancePlanPlanGeneralCostComponent", "cost", element.getCost(), -1);
12818    }
12819    if (element.hasCommentElement()) {
12820      composeString(t, "InsurancePlanPlanGeneralCostComponent", "comment", element.getCommentElement(), -1);
12821    }
12822  }
12823
12824  protected void composeInsurancePlanPlanSpecificCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanSpecificCostComponent element, int index) {
12825    if (element == null) 
12826      return;
12827    Complex t;
12828    if (Utilities.noString(parentType))
12829      t = parent;
12830    else {
12831      t = parent.predicate("fhir:"+parentType+'.'+name);
12832    }
12833    composeBackboneElement(t, "specificCost", name, element, index);
12834    if (element.hasCategory()) {
12835      composeCodeableConcept(t, "InsurancePlanPlanSpecificCostComponent", "category", element.getCategory(), -1);
12836    }
12837    for (int i = 0; i < element.getBenefit().size(); i++) {
12838      composeInsurancePlanPlanBenefitComponent(t, "InsurancePlanPlanSpecificCostComponent", "benefit", element.getBenefit().get(i), i);
12839    }
12840  }
12841
12842  protected void composeInsurancePlanPlanBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitComponent element, int index) {
12843    if (element == null) 
12844      return;
12845    Complex t;
12846    if (Utilities.noString(parentType))
12847      t = parent;
12848    else {
12849      t = parent.predicate("fhir:"+parentType+'.'+name);
12850    }
12851    composeBackboneElement(t, "benefit", name, element, index);
12852    if (element.hasType()) {
12853      composeCodeableConcept(t, "PlanBenefitComponent", "type", element.getType(), -1);
12854    }
12855    for (int i = 0; i < element.getCost().size(); i++) {
12856      composeInsurancePlanPlanBenefitCostComponent(t, "PlanBenefitComponent", "cost", element.getCost().get(i), i);
12857    }
12858  }
12859
12860  protected void composeInsurancePlanPlanBenefitCostComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitCostComponent element, int index) {
12861    if (element == null) 
12862      return;
12863    Complex t;
12864    if (Utilities.noString(parentType))
12865      t = parent;
12866    else {
12867      t = parent.predicate("fhir:"+parentType+'.'+name);
12868    }
12869    composeBackboneElement(t, "cost", name, element, index);
12870    if (element.hasType()) {
12871      composeCodeableConcept(t, "PlanBenefitCostComponent", "type", element.getType(), -1);
12872    }
12873    if (element.hasApplicability()) {
12874      composeCodeableConcept(t, "PlanBenefitCostComponent", "applicability", element.getApplicability(), -1);
12875    }
12876    for (int i = 0; i < element.getQualifiers().size(); i++) {
12877      composeCodeableConcept(t, "PlanBenefitCostComponent", "qualifiers", element.getQualifiers().get(i), i);
12878    }
12879    if (element.hasValue()) {
12880      composeQuantity(t, "PlanBenefitCostComponent", "value", element.getValue(), -1);
12881    }
12882  }
12883
12884  protected void composeInvoice(Complex parent, String parentType, String name, Invoice element, int index) {
12885    if (element == null) 
12886      return;
12887    Complex t;
12888    if (Utilities.noString(parentType))
12889      t = parent;
12890    else {
12891      t = parent.predicate("fhir:"+parentType+'.'+name);
12892    }
12893    composeDomainResource(t, "Invoice", name, element, index);
12894    for (int i = 0; i < element.getIdentifier().size(); i++) {
12895      composeIdentifier(t, "Invoice", "identifier", element.getIdentifier().get(i), i);
12896    }
12897    if (element.hasStatusElement()) {
12898      composeEnum(t, "Invoice", "status", element.getStatusElement(), -1);
12899    }
12900    if (element.hasCancelledReasonElement()) {
12901      composeString(t, "Invoice", "cancelledReason", element.getCancelledReasonElement(), -1);
12902    }
12903    if (element.hasType()) {
12904      composeCodeableConcept(t, "Invoice", "type", element.getType(), -1);
12905    }
12906    if (element.hasSubject()) {
12907      composeReference(t, "Invoice", "subject", element.getSubject(), -1);
12908    }
12909    if (element.hasRecipient()) {
12910      composeReference(t, "Invoice", "recipient", element.getRecipient(), -1);
12911    }
12912    if (element.hasDateElement()) {
12913      composeDateTime(t, "Invoice", "date", element.getDateElement(), -1);
12914    }
12915    for (int i = 0; i < element.getParticipant().size(); i++) {
12916      composeInvoiceParticipantComponent(t, "Invoice", "participant", element.getParticipant().get(i), i);
12917    }
12918    if (element.hasIssuer()) {
12919      composeReference(t, "Invoice", "issuer", element.getIssuer(), -1);
12920    }
12921    if (element.hasAccount()) {
12922      composeReference(t, "Invoice", "account", element.getAccount(), -1);
12923    }
12924    for (int i = 0; i < element.getLineItem().size(); i++) {
12925      composeInvoiceLineItemComponent(t, "Invoice", "lineItem", element.getLineItem().get(i), i);
12926    }
12927    for (int i = 0; i < element.getTotalPriceComponent().size(); i++) {
12928      composeInvoiceLineItemPriceComponentComponent(t, "Invoice", "totalPriceComponent", element.getTotalPriceComponent().get(i), i);
12929    }
12930    if (element.hasTotalNet()) {
12931      composeMoney(t, "Invoice", "totalNet", element.getTotalNet(), -1);
12932    }
12933    if (element.hasTotalGross()) {
12934      composeMoney(t, "Invoice", "totalGross", element.getTotalGross(), -1);
12935    }
12936    if (element.hasPaymentTermsElement()) {
12937      composeMarkdown(t, "Invoice", "paymentTerms", element.getPaymentTermsElement(), -1);
12938    }
12939    for (int i = 0; i < element.getNote().size(); i++) {
12940      composeAnnotation(t, "Invoice", "note", element.getNote().get(i), i);
12941    }
12942  }
12943
12944  protected void composeInvoiceParticipantComponent(Complex parent, String parentType, String name, Invoice.InvoiceParticipantComponent element, int index) {
12945    if (element == null) 
12946      return;
12947    Complex t;
12948    if (Utilities.noString(parentType))
12949      t = parent;
12950    else {
12951      t = parent.predicate("fhir:"+parentType+'.'+name);
12952    }
12953    composeBackboneElement(t, "participant", name, element, index);
12954    if (element.hasRole()) {
12955      composeCodeableConcept(t, "InvoiceParticipantComponent", "role", element.getRole(), -1);
12956    }
12957    if (element.hasActor()) {
12958      composeReference(t, "InvoiceParticipantComponent", "actor", element.getActor(), -1);
12959    }
12960  }
12961
12962  protected void composeInvoiceLineItemComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemComponent element, int index) {
12963    if (element == null) 
12964      return;
12965    Complex t;
12966    if (Utilities.noString(parentType))
12967      t = parent;
12968    else {
12969      t = parent.predicate("fhir:"+parentType+'.'+name);
12970    }
12971    composeBackboneElement(t, "lineItem", name, element, index);
12972    if (element.hasSequenceElement()) {
12973      composePositiveInt(t, "InvoiceLineItemComponent", "sequence", element.getSequenceElement(), -1);
12974    }
12975    if (element.hasChargeItem()) {
12976      composeType(t, "InvoiceLineItemComponent", "chargeItem", element.getChargeItem(), -1);
12977    }
12978    for (int i = 0; i < element.getPriceComponent().size(); i++) {
12979      composeInvoiceLineItemPriceComponentComponent(t, "InvoiceLineItemComponent", "priceComponent", element.getPriceComponent().get(i), i);
12980    }
12981  }
12982
12983  protected void composeInvoiceLineItemPriceComponentComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemPriceComponentComponent element, int index) {
12984    if (element == null) 
12985      return;
12986    Complex t;
12987    if (Utilities.noString(parentType))
12988      t = parent;
12989    else {
12990      t = parent.predicate("fhir:"+parentType+'.'+name);
12991    }
12992    composeBackboneElement(t, "priceComponent", name, element, index);
12993    if (element.hasTypeElement()) {
12994      composeEnum(t, "InvoiceLineItemPriceComponentComponent", "type", element.getTypeElement(), -1);
12995    }
12996    if (element.hasCode()) {
12997      composeCodeableConcept(t, "InvoiceLineItemPriceComponentComponent", "code", element.getCode(), -1);
12998    }
12999    if (element.hasFactorElement()) {
13000      composeDecimal(t, "InvoiceLineItemPriceComponentComponent", "factor", element.getFactorElement(), -1);
13001    }
13002    if (element.hasAmount()) {
13003      composeMoney(t, "InvoiceLineItemPriceComponentComponent", "amount", element.getAmount(), -1);
13004    }
13005  }
13006
13007  protected void composeLibrary(Complex parent, String parentType, String name, Library 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    composeMetadataResource(t, "Library", name, element, index);
13017    if (element.hasUrlElement()) {
13018      composeUri(t, "Library", "url", element.getUrlElement(), -1);
13019    }
13020    for (int i = 0; i < element.getIdentifier().size(); i++) {
13021      composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i);
13022    }
13023    if (element.hasVersionElement()) {
13024      composeString(t, "Library", "version", element.getVersionElement(), -1);
13025    }
13026    if (element.hasNameElement()) {
13027      composeString(t, "Library", "name", element.getNameElement(), -1);
13028    }
13029    if (element.hasTitleElement()) {
13030      composeString(t, "Library", "title", element.getTitleElement(), -1);
13031    }
13032    if (element.hasSubtitleElement()) {
13033      composeString(t, "Library", "subtitle", element.getSubtitleElement(), -1);
13034    }
13035    if (element.hasStatusElement()) {
13036      composeEnum(t, "Library", "status", element.getStatusElement(), -1);
13037    }
13038    if (element.hasExperimentalElement()) {
13039      composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1);
13040    }
13041    if (element.hasType()) {
13042      composeCodeableConcept(t, "Library", "type", element.getType(), -1);
13043    }
13044    if (element.hasSubject()) {
13045      composeType(t, "Library", "subject", element.getSubject(), -1);
13046    }
13047    if (element.hasDateElement()) {
13048      composeDateTime(t, "Library", "date", element.getDateElement(), -1);
13049    }
13050    if (element.hasPublisherElement()) {
13051      composeString(t, "Library", "publisher", element.getPublisherElement(), -1);
13052    }
13053    for (int i = 0; i < element.getContact().size(); i++) {
13054      composeContactDetail(t, "Library", "contact", element.getContact().get(i), i);
13055    }
13056    if (element.hasDescriptionElement()) {
13057      composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1);
13058    }
13059    for (int i = 0; i < element.getUseContext().size(); i++) {
13060      composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i);
13061    }
13062    for (int i = 0; i < element.getJurisdiction().size(); i++) {
13063      composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i);
13064    }
13065    if (element.hasPurposeElement()) {
13066      composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1);
13067    }
13068    if (element.hasUsageElement()) {
13069      composeString(t, "Library", "usage", element.getUsageElement(), -1);
13070    }
13071    if (element.hasCopyrightElement()) {
13072      composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1);
13073    }
13074    if (element.hasApprovalDateElement()) {
13075      composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1);
13076    }
13077    if (element.hasLastReviewDateElement()) {
13078      composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1);
13079    }
13080    if (element.hasEffectivePeriod()) {
13081      composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1);
13082    }
13083    for (int i = 0; i < element.getTopic().size(); i++) {
13084      composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i);
13085    }
13086    for (int i = 0; i < element.getAuthor().size(); i++) {
13087      composeContactDetail(t, "Library", "author", element.getAuthor().get(i), i);
13088    }
13089    for (int i = 0; i < element.getEditor().size(); i++) {
13090      composeContactDetail(t, "Library", "editor", element.getEditor().get(i), i);
13091    }
13092    for (int i = 0; i < element.getReviewer().size(); i++) {
13093      composeContactDetail(t, "Library", "reviewer", element.getReviewer().get(i), i);
13094    }
13095    for (int i = 0; i < element.getEndorser().size(); i++) {
13096      composeContactDetail(t, "Library", "endorser", element.getEndorser().get(i), i);
13097    }
13098    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
13099      composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i);
13100    }
13101    for (int i = 0; i < element.getParameter().size(); i++) {
13102      composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i);
13103    }
13104    for (int i = 0; i < element.getDataRequirement().size(); i++) {
13105      composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i);
13106    }
13107    for (int i = 0; i < element.getContent().size(); i++) {
13108      composeAttachment(t, "Library", "content", element.getContent().get(i), i);
13109    }
13110  }
13111
13112  protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) {
13113    if (element == null) 
13114      return;
13115    Complex t;
13116    if (Utilities.noString(parentType))
13117      t = parent;
13118    else {
13119      t = parent.predicate("fhir:"+parentType+'.'+name);
13120    }
13121    composeDomainResource(t, "Linkage", name, element, index);
13122    if (element.hasActiveElement()) {
13123      composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1);
13124    }
13125    if (element.hasAuthor()) {
13126      composeReference(t, "Linkage", "author", element.getAuthor(), -1);
13127    }
13128    for (int i = 0; i < element.getItem().size(); i++) {
13129      composeLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i);
13130    }
13131  }
13132
13133  protected void composeLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) {
13134    if (element == null) 
13135      return;
13136    Complex t;
13137    if (Utilities.noString(parentType))
13138      t = parent;
13139    else {
13140      t = parent.predicate("fhir:"+parentType+'.'+name);
13141    }
13142    composeBackboneElement(t, "item", name, element, index);
13143    if (element.hasTypeElement()) {
13144      composeEnum(t, "LinkageItemComponent", "type", element.getTypeElement(), -1);
13145    }
13146    if (element.hasResource()) {
13147      composeReference(t, "LinkageItemComponent", "resource", element.getResource(), -1);
13148    }
13149  }
13150
13151  protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) {
13152    if (element == null) 
13153      return;
13154    Complex t;
13155    if (Utilities.noString(parentType))
13156      t = parent;
13157    else {
13158      t = parent.predicate("fhir:"+parentType+'.'+name);
13159    }
13160    composeDomainResource(t, "List", name, element, index);
13161    for (int i = 0; i < element.getIdentifier().size(); i++) {
13162      composeIdentifier(t, "ListResource", "identifier", element.getIdentifier().get(i), i);
13163    }
13164    if (element.hasStatusElement()) {
13165      composeEnum(t, "ListResource", "status", element.getStatusElement(), -1);
13166    }
13167    if (element.hasModeElement()) {
13168      composeEnum(t, "ListResource", "mode", element.getModeElement(), -1);
13169    }
13170    if (element.hasTitleElement()) {
13171      composeString(t, "ListResource", "title", element.getTitleElement(), -1);
13172    }
13173    if (element.hasCode()) {
13174      composeCodeableConcept(t, "ListResource", "code", element.getCode(), -1);
13175    }
13176    if (element.hasSubject()) {
13177      composeReference(t, "ListResource", "subject", element.getSubject(), -1);
13178    }
13179    if (element.hasEncounter()) {
13180      composeReference(t, "ListResource", "encounter", element.getEncounter(), -1);
13181    }
13182    if (element.hasDateElement()) {
13183      composeDateTime(t, "ListResource", "date", element.getDateElement(), -1);
13184    }
13185    if (element.hasSource()) {
13186      composeReference(t, "ListResource", "source", element.getSource(), -1);
13187    }
13188    if (element.hasOrderedBy()) {
13189      composeCodeableConcept(t, "ListResource", "orderedBy", element.getOrderedBy(), -1);
13190    }
13191    for (int i = 0; i < element.getNote().size(); i++) {
13192      composeAnnotation(t, "ListResource", "note", element.getNote().get(i), i);
13193    }
13194    for (int i = 0; i < element.getEntry().size(); i++) {
13195      composeListResourceEntryComponent(t, "ListResource", "entry", element.getEntry().get(i), i);
13196    }
13197    if (element.hasEmptyReason()) {
13198      composeCodeableConcept(t, "ListResource", "emptyReason", element.getEmptyReason(), -1);
13199    }
13200  }
13201
13202  protected void composeListResourceEntryComponent(Complex parent, String parentType, String name, ListResource.ListResourceEntryComponent element, int index) {
13203    if (element == null) 
13204      return;
13205    Complex t;
13206    if (Utilities.noString(parentType))
13207      t = parent;
13208    else {
13209      t = parent.predicate("fhir:"+parentType+'.'+name);
13210    }
13211    composeBackboneElement(t, "entry", name, element, index);
13212    if (element.hasFlag()) {
13213      composeCodeableConcept(t, "ListResourceEntryComponent", "flag", element.getFlag(), -1);
13214    }
13215    if (element.hasDeletedElement()) {
13216      composeBoolean(t, "ListResourceEntryComponent", "deleted", element.getDeletedElement(), -1);
13217    }
13218    if (element.hasDateElement()) {
13219      composeDateTime(t, "ListResourceEntryComponent", "date", element.getDateElement(), -1);
13220    }
13221    if (element.hasItem()) {
13222      composeReference(t, "ListResourceEntryComponent", "item", element.getItem(), -1);
13223    }
13224  }
13225
13226  protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) {
13227    if (element == null) 
13228      return;
13229    Complex t;
13230    if (Utilities.noString(parentType))
13231      t = parent;
13232    else {
13233      t = parent.predicate("fhir:"+parentType+'.'+name);
13234    }
13235    composeDomainResource(t, "Location", name, element, index);
13236    for (int i = 0; i < element.getIdentifier().size(); i++) {
13237      composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i);
13238    }
13239    if (element.hasStatusElement()) {
13240      composeEnum(t, "Location", "status", element.getStatusElement(), -1);
13241    }
13242    if (element.hasOperationalStatus()) {
13243      composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1);
13244    }
13245    if (element.hasNameElement()) {
13246      composeString(t, "Location", "name", element.getNameElement(), -1);
13247    }
13248    for (int i = 0; i < element.getAlias().size(); i++) {
13249      composeString(t, "Location", "alias", element.getAlias().get(i), i);
13250    }
13251    if (element.hasDescriptionElement()) {
13252      composeString(t, "Location", "description", element.getDescriptionElement(), -1);
13253    }
13254    if (element.hasModeElement()) {
13255      composeEnum(t, "Location", "mode", element.getModeElement(), -1);
13256    }
13257    for (int i = 0; i < element.getType().size(); i++) {
13258      composeCodeableConcept(t, "Location", "type", element.getType().get(i), i);
13259    }
13260    for (int i = 0; i < element.getTelecom().size(); i++) {
13261      composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i);
13262    }
13263    if (element.hasAddress()) {
13264      composeAddress(t, "Location", "address", element.getAddress(), -1);
13265    }
13266    if (element.hasPhysicalType()) {
13267      composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1);
13268    }
13269    if (element.hasPosition()) {
13270      composeLocationPositionComponent(t, "Location", "position", element.getPosition(), -1);
13271    }
13272    if (element.hasManagingOrganization()) {
13273      composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1);
13274    }
13275    if (element.hasPartOf()) {
13276      composeReference(t, "Location", "partOf", element.getPartOf(), -1);
13277    }
13278    for (int i = 0; i < element.getHoursOfOperation().size(); i++) {
13279      composeLocationHoursOfOperationComponent(t, "Location", "hoursOfOperation", element.getHoursOfOperation().get(i), i);
13280    }
13281    if (element.hasAvailabilityExceptionsElement()) {
13282      composeString(t, "Location", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
13283    }
13284    for (int i = 0; i < element.getEndpoint().size(); i++) {
13285      composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i);
13286    }
13287  }
13288
13289  protected void composeLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) {
13290    if (element == null) 
13291      return;
13292    Complex t;
13293    if (Utilities.noString(parentType))
13294      t = parent;
13295    else {
13296      t = parent.predicate("fhir:"+parentType+'.'+name);
13297    }
13298    composeBackboneElement(t, "position", name, element, index);
13299    if (element.hasLongitudeElement()) {
13300      composeDecimal(t, "LocationPositionComponent", "longitude", element.getLongitudeElement(), -1);
13301    }
13302    if (element.hasLatitudeElement()) {
13303      composeDecimal(t, "LocationPositionComponent", "latitude", element.getLatitudeElement(), -1);
13304    }
13305    if (element.hasAltitudeElement()) {
13306      composeDecimal(t, "LocationPositionComponent", "altitude", element.getAltitudeElement(), -1);
13307    }
13308  }
13309
13310  protected void composeLocationHoursOfOperationComponent(Complex parent, String parentType, String name, Location.LocationHoursOfOperationComponent element, int index) {
13311    if (element == null) 
13312      return;
13313    Complex t;
13314    if (Utilities.noString(parentType))
13315      t = parent;
13316    else {
13317      t = parent.predicate("fhir:"+parentType+'.'+name);
13318    }
13319    composeBackboneElement(t, "hoursOfOperation", name, element, index);
13320    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
13321      composeEnum(t, "LocationHoursOfOperationComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
13322    }
13323    if (element.hasAllDayElement()) {
13324      composeBoolean(t, "LocationHoursOfOperationComponent", "allDay", element.getAllDayElement(), -1);
13325    }
13326    if (element.hasOpeningTimeElement()) {
13327      composeTime(t, "LocationHoursOfOperationComponent", "openingTime", element.getOpeningTimeElement(), -1);
13328    }
13329    if (element.hasClosingTimeElement()) {
13330      composeTime(t, "LocationHoursOfOperationComponent", "closingTime", element.getClosingTimeElement(), -1);
13331    }
13332  }
13333
13334  protected void composeManufacturedItemDefinition(Complex parent, String parentType, String name, ManufacturedItemDefinition element, int index) {
13335    if (element == null) 
13336      return;
13337    Complex t;
13338    if (Utilities.noString(parentType))
13339      t = parent;
13340    else {
13341      t = parent.predicate("fhir:"+parentType+'.'+name);
13342    }
13343    composeDomainResource(t, "ManufacturedItemDefinition", name, element, index);
13344    for (int i = 0; i < element.getIdentifier().size(); i++) {
13345      composeIdentifier(t, "ManufacturedItemDefinition", "identifier", element.getIdentifier().get(i), i);
13346    }
13347    if (element.hasManufacturedDoseForm()) {
13348      composeCodeableConcept(t, "ManufacturedItemDefinition", "manufacturedDoseForm", element.getManufacturedDoseForm(), -1);
13349    }
13350    if (element.hasUnitOfPresentation()) {
13351      composeCodeableConcept(t, "ManufacturedItemDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1);
13352    }
13353    for (int i = 0; i < element.getManufacturer().size(); i++) {
13354      composeReference(t, "ManufacturedItemDefinition", "manufacturer", element.getManufacturer().get(i), i);
13355    }
13356    for (int i = 0; i < element.getIngredient().size(); i++) {
13357      composeReference(t, "ManufacturedItemDefinition", "ingredient", element.getIngredient().get(i), i);
13358    }
13359    for (int i = 0; i < element.getCharacteristic().size(); i++) {
13360      composeManufacturedItemDefinitionCharacteristicComponent(t, "ManufacturedItemDefinition", "characteristic", element.getCharacteristic().get(i), i);
13361    }
13362  }
13363
13364  protected void composeManufacturedItemDefinitionCharacteristicComponent(Complex parent, String parentType, String name, ManufacturedItemDefinition.ManufacturedItemDefinitionCharacteristicComponent element, int index) {
13365    if (element == null) 
13366      return;
13367    Complex t;
13368    if (Utilities.noString(parentType))
13369      t = parent;
13370    else {
13371      t = parent.predicate("fhir:"+parentType+'.'+name);
13372    }
13373    composeBackboneElement(t, "characteristic", name, element, index);
13374    if (element.hasCode()) {
13375      composeCodeableConcept(t, "ManufacturedItemDefinitionCharacteristicComponent", "code", element.getCode(), -1);
13376    }
13377    if (element.hasValue()) {
13378      composeType(t, "ManufacturedItemDefinitionCharacteristicComponent", "value", element.getValue(), -1);
13379    }
13380  }
13381
13382  protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) {
13383    if (element == null) 
13384      return;
13385    Complex t;
13386    if (Utilities.noString(parentType))
13387      t = parent;
13388    else {
13389      t = parent.predicate("fhir:"+parentType+'.'+name);
13390    }
13391    composeMetadataResource(t, "Measure", name, element, index);
13392    if (element.hasUrlElement()) {
13393      composeUri(t, "Measure", "url", element.getUrlElement(), -1);
13394    }
13395    for (int i = 0; i < element.getIdentifier().size(); i++) {
13396      composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i);
13397    }
13398    if (element.hasVersionElement()) {
13399      composeString(t, "Measure", "version", element.getVersionElement(), -1);
13400    }
13401    if (element.hasNameElement()) {
13402      composeString(t, "Measure", "name", element.getNameElement(), -1);
13403    }
13404    if (element.hasTitleElement()) {
13405      composeString(t, "Measure", "title", element.getTitleElement(), -1);
13406    }
13407    if (element.hasSubtitleElement()) {
13408      composeString(t, "Measure", "subtitle", element.getSubtitleElement(), -1);
13409    }
13410    if (element.hasStatusElement()) {
13411      composeEnum(t, "Measure", "status", element.getStatusElement(), -1);
13412    }
13413    if (element.hasExperimentalElement()) {
13414      composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1);
13415    }
13416    if (element.hasSubject()) {
13417      composeType(t, "Measure", "subject", element.getSubject(), -1);
13418    }
13419    if (element.hasDateElement()) {
13420      composeDateTime(t, "Measure", "date", element.getDateElement(), -1);
13421    }
13422    if (element.hasPublisherElement()) {
13423      composeString(t, "Measure", "publisher", element.getPublisherElement(), -1);
13424    }
13425    for (int i = 0; i < element.getContact().size(); i++) {
13426      composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i);
13427    }
13428    if (element.hasDescriptionElement()) {
13429      composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1);
13430    }
13431    for (int i = 0; i < element.getUseContext().size(); i++) {
13432      composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i);
13433    }
13434    for (int i = 0; i < element.getJurisdiction().size(); i++) {
13435      composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i);
13436    }
13437    if (element.hasPurposeElement()) {
13438      composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1);
13439    }
13440    if (element.hasUsageElement()) {
13441      composeString(t, "Measure", "usage", element.getUsageElement(), -1);
13442    }
13443    if (element.hasCopyrightElement()) {
13444      composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1);
13445    }
13446    if (element.hasApprovalDateElement()) {
13447      composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1);
13448    }
13449    if (element.hasLastReviewDateElement()) {
13450      composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1);
13451    }
13452    if (element.hasEffectivePeriod()) {
13453      composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1);
13454    }
13455    for (int i = 0; i < element.getTopic().size(); i++) {
13456      composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i);
13457    }
13458    for (int i = 0; i < element.getAuthor().size(); i++) {
13459      composeContactDetail(t, "Measure", "author", element.getAuthor().get(i), i);
13460    }
13461    for (int i = 0; i < element.getEditor().size(); i++) {
13462      composeContactDetail(t, "Measure", "editor", element.getEditor().get(i), i);
13463    }
13464    for (int i = 0; i < element.getReviewer().size(); i++) {
13465      composeContactDetail(t, "Measure", "reviewer", element.getReviewer().get(i), i);
13466    }
13467    for (int i = 0; i < element.getEndorser().size(); i++) {
13468      composeContactDetail(t, "Measure", "endorser", element.getEndorser().get(i), i);
13469    }
13470    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
13471      composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i);
13472    }
13473    for (int i = 0; i < element.getLibrary().size(); i++) {
13474      composeCanonical(t, "Measure", "library", element.getLibrary().get(i), i);
13475    }
13476    if (element.hasDisclaimerElement()) {
13477      composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1);
13478    }
13479    if (element.hasScoring()) {
13480      composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1);
13481    }
13482    if (element.hasCompositeScoring()) {
13483      composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1);
13484    }
13485    for (int i = 0; i < element.getType().size(); i++) {
13486      composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i);
13487    }
13488    if (element.hasRiskAdjustmentElement()) {
13489      composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1);
13490    }
13491    if (element.hasRateAggregationElement()) {
13492      composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1);
13493    }
13494    if (element.hasRationaleElement()) {
13495      composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1);
13496    }
13497    if (element.hasClinicalRecommendationStatementElement()) {
13498      composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1);
13499    }
13500    if (element.hasImprovementNotation()) {
13501      composeCodeableConcept(t, "Measure", "improvementNotation", element.getImprovementNotation(), -1);
13502    }
13503    for (int i = 0; i < element.getDefinition().size(); i++) {
13504      composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i);
13505    }
13506    if (element.hasGuidanceElement()) {
13507      composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1);
13508    }
13509    for (int i = 0; i < element.getGroup().size(); i++) {
13510      composeMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i);
13511    }
13512    for (int i = 0; i < element.getSupplementalData().size(); i++) {
13513      composeMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i);
13514    }
13515  }
13516
13517  protected void composeMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) {
13518    if (element == null) 
13519      return;
13520    Complex t;
13521    if (Utilities.noString(parentType))
13522      t = parent;
13523    else {
13524      t = parent.predicate("fhir:"+parentType+'.'+name);
13525    }
13526    composeBackboneElement(t, "group", name, element, index);
13527    if (element.hasCode()) {
13528      composeCodeableConcept(t, "MeasureGroupComponent", "code", element.getCode(), -1);
13529    }
13530    if (element.hasDescriptionElement()) {
13531      composeString(t, "MeasureGroupComponent", "description", element.getDescriptionElement(), -1);
13532    }
13533    for (int i = 0; i < element.getPopulation().size(); i++) {
13534      composeMeasureGroupPopulationComponent(t, "MeasureGroupComponent", "population", element.getPopulation().get(i), i);
13535    }
13536    for (int i = 0; i < element.getStratifier().size(); i++) {
13537      composeMeasureGroupStratifierComponent(t, "MeasureGroupComponent", "stratifier", element.getStratifier().get(i), i);
13538    }
13539  }
13540
13541  protected void composeMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) {
13542    if (element == null) 
13543      return;
13544    Complex t;
13545    if (Utilities.noString(parentType))
13546      t = parent;
13547    else {
13548      t = parent.predicate("fhir:"+parentType+'.'+name);
13549    }
13550    composeBackboneElement(t, "population", name, element, index);
13551    if (element.hasCode()) {
13552      composeCodeableConcept(t, "MeasureGroupPopulationComponent", "code", element.getCode(), -1);
13553    }
13554    if (element.hasDescriptionElement()) {
13555      composeString(t, "MeasureGroupPopulationComponent", "description", element.getDescriptionElement(), -1);
13556    }
13557    if (element.hasCriteria()) {
13558      composeExpression(t, "MeasureGroupPopulationComponent", "criteria", element.getCriteria(), -1);
13559    }
13560  }
13561
13562  protected void composeMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) {
13563    if (element == null) 
13564      return;
13565    Complex t;
13566    if (Utilities.noString(parentType))
13567      t = parent;
13568    else {
13569      t = parent.predicate("fhir:"+parentType+'.'+name);
13570    }
13571    composeBackboneElement(t, "stratifier", name, element, index);
13572    if (element.hasCode()) {
13573      composeCodeableConcept(t, "MeasureGroupStratifierComponent", "code", element.getCode(), -1);
13574    }
13575    if (element.hasDescriptionElement()) {
13576      composeString(t, "MeasureGroupStratifierComponent", "description", element.getDescriptionElement(), -1);
13577    }
13578    if (element.hasCriteria()) {
13579      composeExpression(t, "MeasureGroupStratifierComponent", "criteria", element.getCriteria(), -1);
13580    }
13581    for (int i = 0; i < element.getComponent().size(); i++) {
13582      composeMeasureGroupStratifierComponentComponent(t, "MeasureGroupStratifierComponent", "component", element.getComponent().get(i), i);
13583    }
13584  }
13585
13586  protected void composeMeasureGroupStratifierComponentComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponentComponent element, int index) {
13587    if (element == null) 
13588      return;
13589    Complex t;
13590    if (Utilities.noString(parentType))
13591      t = parent;
13592    else {
13593      t = parent.predicate("fhir:"+parentType+'.'+name);
13594    }
13595    composeBackboneElement(t, "component", name, element, index);
13596    if (element.hasCode()) {
13597      composeCodeableConcept(t, "MeasureGroupStratifierComponentComponent", "code", element.getCode(), -1);
13598    }
13599    if (element.hasDescriptionElement()) {
13600      composeString(t, "MeasureGroupStratifierComponentComponent", "description", element.getDescriptionElement(), -1);
13601    }
13602    if (element.hasCriteria()) {
13603      composeExpression(t, "MeasureGroupStratifierComponentComponent", "criteria", element.getCriteria(), -1);
13604    }
13605  }
13606
13607  protected void composeMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) {
13608    if (element == null) 
13609      return;
13610    Complex t;
13611    if (Utilities.noString(parentType))
13612      t = parent;
13613    else {
13614      t = parent.predicate("fhir:"+parentType+'.'+name);
13615    }
13616    composeBackboneElement(t, "supplementalData", name, element, index);
13617    if (element.hasCode()) {
13618      composeCodeableConcept(t, "MeasureSupplementalDataComponent", "code", element.getCode(), -1);
13619    }
13620    for (int i = 0; i < element.getUsage().size(); i++) {
13621      composeCodeableConcept(t, "MeasureSupplementalDataComponent", "usage", element.getUsage().get(i), i);
13622    }
13623    if (element.hasDescriptionElement()) {
13624      composeString(t, "MeasureSupplementalDataComponent", "description", element.getDescriptionElement(), -1);
13625    }
13626    if (element.hasCriteria()) {
13627      composeExpression(t, "MeasureSupplementalDataComponent", "criteria", element.getCriteria(), -1);
13628    }
13629  }
13630
13631  protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) {
13632    if (element == null) 
13633      return;
13634    Complex t;
13635    if (Utilities.noString(parentType))
13636      t = parent;
13637    else {
13638      t = parent.predicate("fhir:"+parentType+'.'+name);
13639    }
13640    composeDomainResource(t, "MeasureReport", name, element, index);
13641    for (int i = 0; i < element.getIdentifier().size(); i++) {
13642      composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier().get(i), i);
13643    }
13644    if (element.hasStatusElement()) {
13645      composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1);
13646    }
13647    if (element.hasTypeElement()) {
13648      composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1);
13649    }
13650    if (element.hasMeasureElement()) {
13651      composeCanonical(t, "MeasureReport", "measure", element.getMeasureElement(), -1);
13652    }
13653    if (element.hasSubject()) {
13654      composeReference(t, "MeasureReport", "subject", element.getSubject(), -1);
13655    }
13656    if (element.hasDateElement()) {
13657      composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1);
13658    }
13659    if (element.hasReporter()) {
13660      composeReference(t, "MeasureReport", "reporter", element.getReporter(), -1);
13661    }
13662    if (element.hasPeriod()) {
13663      composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1);
13664    }
13665    if (element.hasImprovementNotation()) {
13666      composeCodeableConcept(t, "MeasureReport", "improvementNotation", element.getImprovementNotation(), -1);
13667    }
13668    for (int i = 0; i < element.getGroup().size(); i++) {
13669      composeMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i);
13670    }
13671    for (int i = 0; i < element.getEvaluatedResource().size(); i++) {
13672      composeReference(t, "MeasureReport", "evaluatedResource", element.getEvaluatedResource().get(i), i);
13673    }
13674  }
13675
13676  protected void composeMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) {
13677    if (element == null) 
13678      return;
13679    Complex t;
13680    if (Utilities.noString(parentType))
13681      t = parent;
13682    else {
13683      t = parent.predicate("fhir:"+parentType+'.'+name);
13684    }
13685    composeBackboneElement(t, "group", name, element, index);
13686    if (element.hasCode()) {
13687      composeCodeableConcept(t, "MeasureReportGroupComponent", "code", element.getCode(), -1);
13688    }
13689    for (int i = 0; i < element.getPopulation().size(); i++) {
13690      composeMeasureReportGroupPopulationComponent(t, "MeasureReportGroupComponent", "population", element.getPopulation().get(i), i);
13691    }
13692    if (element.hasMeasureScore()) {
13693      composeQuantity(t, "MeasureReportGroupComponent", "measureScore", element.getMeasureScore(), -1);
13694    }
13695    for (int i = 0; i < element.getStratifier().size(); i++) {
13696      composeMeasureReportGroupStratifierComponent(t, "MeasureReportGroupComponent", "stratifier", element.getStratifier().get(i), i);
13697    }
13698  }
13699
13700  protected void composeMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) {
13701    if (element == null) 
13702      return;
13703    Complex t;
13704    if (Utilities.noString(parentType))
13705      t = parent;
13706    else {
13707      t = parent.predicate("fhir:"+parentType+'.'+name);
13708    }
13709    composeBackboneElement(t, "population", name, element, index);
13710    if (element.hasCode()) {
13711      composeCodeableConcept(t, "MeasureReportGroupPopulationComponent", "code", element.getCode(), -1);
13712    }
13713    if (element.hasCountElement()) {
13714      composeInteger(t, "MeasureReportGroupPopulationComponent", "count", element.getCountElement(), -1);
13715    }
13716    if (element.hasSubjectResults()) {
13717      composeReference(t, "MeasureReportGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1);
13718    }
13719  }
13720
13721  protected void composeMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) {
13722    if (element == null) 
13723      return;
13724    Complex t;
13725    if (Utilities.noString(parentType))
13726      t = parent;
13727    else {
13728      t = parent.predicate("fhir:"+parentType+'.'+name);
13729    }
13730    composeBackboneElement(t, "stratifier", name, element, index);
13731    for (int i = 0; i < element.getCode().size(); i++) {
13732      composeCodeableConcept(t, "MeasureReportGroupStratifierComponent", "code", element.getCode().get(i), i);
13733    }
13734    for (int i = 0; i < element.getStratum().size(); i++) {
13735      composeMeasureReportStratifierGroupComponent(t, "MeasureReportGroupStratifierComponent", "stratum", element.getStratum().get(i), i);
13736    }
13737  }
13738
13739  protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) {
13740    if (element == null) 
13741      return;
13742    Complex t;
13743    if (Utilities.noString(parentType))
13744      t = parent;
13745    else {
13746      t = parent.predicate("fhir:"+parentType+'.'+name);
13747    }
13748    composeBackboneElement(t, "stratum", name, element, index);
13749    if (element.hasValue()) {
13750      composeCodeableConcept(t, "StratifierGroupComponent", "value", element.getValue(), -1);
13751    }
13752    for (int i = 0; i < element.getComponent().size(); i++) {
13753      composeMeasureReportStratifierGroupComponentComponent(t, "StratifierGroupComponent", "component", element.getComponent().get(i), i);
13754    }
13755    for (int i = 0; i < element.getPopulation().size(); i++) {
13756      composeMeasureReportStratifierGroupPopulationComponent(t, "StratifierGroupComponent", "population", element.getPopulation().get(i), i);
13757    }
13758    if (element.hasMeasureScore()) {
13759      composeQuantity(t, "StratifierGroupComponent", "measureScore", element.getMeasureScore(), -1);
13760    }
13761  }
13762
13763  protected void composeMeasureReportStratifierGroupComponentComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponentComponent element, int index) {
13764    if (element == null) 
13765      return;
13766    Complex t;
13767    if (Utilities.noString(parentType))
13768      t = parent;
13769    else {
13770      t = parent.predicate("fhir:"+parentType+'.'+name);
13771    }
13772    composeBackboneElement(t, "component", name, element, index);
13773    if (element.hasCode()) {
13774      composeCodeableConcept(t, "StratifierGroupComponentComponent", "code", element.getCode(), -1);
13775    }
13776    if (element.hasValue()) {
13777      composeCodeableConcept(t, "StratifierGroupComponentComponent", "value", element.getValue(), -1);
13778    }
13779  }
13780
13781  protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) {
13782    if (element == null) 
13783      return;
13784    Complex t;
13785    if (Utilities.noString(parentType))
13786      t = parent;
13787    else {
13788      t = parent.predicate("fhir:"+parentType+'.'+name);
13789    }
13790    composeBackboneElement(t, "population", name, element, index);
13791    if (element.hasCode()) {
13792      composeCodeableConcept(t, "StratifierGroupPopulationComponent", "code", element.getCode(), -1);
13793    }
13794    if (element.hasCountElement()) {
13795      composeInteger(t, "StratifierGroupPopulationComponent", "count", element.getCountElement(), -1);
13796    }
13797    if (element.hasSubjectResults()) {
13798      composeReference(t, "StratifierGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1);
13799    }
13800  }
13801
13802  protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) {
13803    if (element == null) 
13804      return;
13805    Complex t;
13806    if (Utilities.noString(parentType))
13807      t = parent;
13808    else {
13809      t = parent.predicate("fhir:"+parentType+'.'+name);
13810    }
13811    composeDomainResource(t, "Medication", name, element, index);
13812    for (int i = 0; i < element.getIdentifier().size(); i++) {
13813      composeIdentifier(t, "Medication", "identifier", element.getIdentifier().get(i), i);
13814    }
13815    if (element.hasCode()) {
13816      composeCodeableConcept(t, "Medication", "code", element.getCode(), -1);
13817    }
13818    if (element.hasStatusElement()) {
13819      composeEnum(t, "Medication", "status", element.getStatusElement(), -1);
13820    }
13821    if (element.hasManufacturer()) {
13822      composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1);
13823    }
13824    if (element.hasDoseForm()) {
13825      composeCodeableConcept(t, "Medication", "doseForm", element.getDoseForm(), -1);
13826    }
13827    if (element.hasAmount()) {
13828      composeRatio(t, "Medication", "amount", element.getAmount(), -1);
13829    }
13830    for (int i = 0; i < element.getIngredient().size(); i++) {
13831      composeMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i);
13832    }
13833    if (element.hasBatch()) {
13834      composeMedicationBatchComponent(t, "Medication", "batch", element.getBatch(), -1);
13835    }
13836  }
13837
13838  protected void composeMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent element, int index) {
13839    if (element == null) 
13840      return;
13841    Complex t;
13842    if (Utilities.noString(parentType))
13843      t = parent;
13844    else {
13845      t = parent.predicate("fhir:"+parentType+'.'+name);
13846    }
13847    composeBackboneElement(t, "ingredient", name, element, index);
13848    if (element.hasItem()) {
13849      composeType(t, "MedicationIngredientComponent", "item", element.getItem(), -1);
13850    }
13851    if (element.hasIsActiveElement()) {
13852      composeBoolean(t, "MedicationIngredientComponent", "isActive", element.getIsActiveElement(), -1);
13853    }
13854    if (element.hasStrength()) {
13855      composeType(t, "MedicationIngredientComponent", "strength", element.getStrength(), -1);
13856    }
13857  }
13858
13859  protected void composeMedicationBatchComponent(Complex parent, String parentType, String name, Medication.MedicationBatchComponent element, int index) {
13860    if (element == null) 
13861      return;
13862    Complex t;
13863    if (Utilities.noString(parentType))
13864      t = parent;
13865    else {
13866      t = parent.predicate("fhir:"+parentType+'.'+name);
13867    }
13868    composeBackboneElement(t, "batch", name, element, index);
13869    if (element.hasLotNumberElement()) {
13870      composeString(t, "MedicationBatchComponent", "lotNumber", element.getLotNumberElement(), -1);
13871    }
13872    if (element.hasExpirationDateElement()) {
13873      composeDateTime(t, "MedicationBatchComponent", "expirationDate", element.getExpirationDateElement(), -1);
13874    }
13875  }
13876
13877  protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) {
13878    if (element == null) 
13879      return;
13880    Complex t;
13881    if (Utilities.noString(parentType))
13882      t = parent;
13883    else {
13884      t = parent.predicate("fhir:"+parentType+'.'+name);
13885    }
13886    composeDomainResource(t, "MedicationAdministration", name, element, index);
13887    for (int i = 0; i < element.getIdentifier().size(); i++) {
13888      composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i);
13889    }
13890    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
13891      composeCanonical(t, "MedicationAdministration", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
13892    }
13893    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
13894      composeUri(t, "MedicationAdministration", "instantiatesUri", element.getInstantiatesUri().get(i), i);
13895    }
13896    for (int i = 0; i < element.getBasedOn().size(); i++) {
13897      composeReference(t, "MedicationAdministration", "basedOn", element.getBasedOn().get(i), i);
13898    }
13899    for (int i = 0; i < element.getPartOf().size(); i++) {
13900      composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i);
13901    }
13902    if (element.hasStatusElement()) {
13903      composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1);
13904    }
13905    for (int i = 0; i < element.getStatusReason().size(); i++) {
13906      composeCodeableConcept(t, "MedicationAdministration", "statusReason", element.getStatusReason().get(i), i);
13907    }
13908    for (int i = 0; i < element.getCategory().size(); i++) {
13909      composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory().get(i), i);
13910    }
13911    if (element.hasMedication()) {
13912      composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1);
13913    }
13914    if (element.hasSubject()) {
13915      composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1);
13916    }
13917    if (element.hasEncounter()) {
13918      composeReference(t, "MedicationAdministration", "encounter", element.getEncounter(), -1);
13919    }
13920    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
13921      composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i);
13922    }
13923    if (element.hasOccurence()) {
13924      composeType(t, "MedicationAdministration", "occurence", element.getOccurence(), -1);
13925    }
13926    if (element.hasRecordedElement()) {
13927      composeDateTime(t, "MedicationAdministration", "recorded", element.getRecordedElement(), -1);
13928    }
13929    for (int i = 0; i < element.getPerformer().size(); i++) {
13930      composeMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i);
13931    }
13932    for (int i = 0; i < element.getReason().size(); i++) {
13933      composeCodeableReference(t, "MedicationAdministration", "reason", element.getReason().get(i), i);
13934    }
13935    if (element.hasRequest()) {
13936      composeReference(t, "MedicationAdministration", "request", element.getRequest(), -1);
13937    }
13938    for (int i = 0; i < element.getDevice().size(); i++) {
13939      composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i);
13940    }
13941    for (int i = 0; i < element.getNote().size(); i++) {
13942      composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i);
13943    }
13944    if (element.hasDosage()) {
13945      composeMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1);
13946    }
13947    for (int i = 0; i < element.getEventHistory().size(); i++) {
13948      composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i);
13949    }
13950  }
13951
13952  protected void composeMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent element, int index) {
13953    if (element == null) 
13954      return;
13955    Complex t;
13956    if (Utilities.noString(parentType))
13957      t = parent;
13958    else {
13959      t = parent.predicate("fhir:"+parentType+'.'+name);
13960    }
13961    composeBackboneElement(t, "performer", name, element, index);
13962    if (element.hasFunction()) {
13963      composeCodeableConcept(t, "MedicationAdministrationPerformerComponent", "function", element.getFunction(), -1);
13964    }
13965    if (element.hasActor()) {
13966      composeReference(t, "MedicationAdministrationPerformerComponent", "actor", element.getActor(), -1);
13967    }
13968  }
13969
13970  protected void composeMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent 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    composeBackboneElement(t, "dosage", name, element, index);
13980    if (element.hasTextElement()) {
13981      composeString(t, "MedicationAdministrationDosageComponent", "text", element.getTextElement(), -1);
13982    }
13983    if (element.hasSite()) {
13984      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "site", element.getSite(), -1);
13985    }
13986    if (element.hasRoute()) {
13987      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "route", element.getRoute(), -1);
13988    }
13989    if (element.hasMethod()) {
13990      composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "method", element.getMethod(), -1);
13991    }
13992    if (element.hasDose()) {
13993      composeQuantity(t, "MedicationAdministrationDosageComponent", "dose", element.getDose(), -1);
13994    }
13995    if (element.hasRate()) {
13996      composeType(t, "MedicationAdministrationDosageComponent", "rate", element.getRate(), -1);
13997    }
13998  }
13999
14000  protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) {
14001    if (element == null) 
14002      return;
14003    Complex t;
14004    if (Utilities.noString(parentType))
14005      t = parent;
14006    else {
14007      t = parent.predicate("fhir:"+parentType+'.'+name);
14008    }
14009    composeDomainResource(t, "MedicationDispense", name, element, index);
14010    for (int i = 0; i < element.getIdentifier().size(); i++) {
14011      composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i);
14012    }
14013    for (int i = 0; i < element.getBasedOn().size(); i++) {
14014      composeReference(t, "MedicationDispense", "basedOn", element.getBasedOn().get(i), i);
14015    }
14016    for (int i = 0; i < element.getPartOf().size(); i++) {
14017      composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i);
14018    }
14019    if (element.hasStatusElement()) {
14020      composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1);
14021    }
14022    if (element.hasStatusReason()) {
14023      composeType(t, "MedicationDispense", "statusReason", element.getStatusReason(), -1);
14024    }
14025    for (int i = 0; i < element.getCategory().size(); i++) {
14026      composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory().get(i), i);
14027    }
14028    if (element.hasMedication()) {
14029      composeType(t, "MedicationDispense", "medication", element.getMedication(), -1);
14030    }
14031    if (element.hasSubject()) {
14032      composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1);
14033    }
14034    if (element.hasEncounter()) {
14035      composeReference(t, "MedicationDispense", "encounter", element.getEncounter(), -1);
14036    }
14037    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
14038      composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i);
14039    }
14040    for (int i = 0; i < element.getPerformer().size(); i++) {
14041      composeMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i);
14042    }
14043    if (element.hasLocation()) {
14044      composeReference(t, "MedicationDispense", "location", element.getLocation(), -1);
14045    }
14046    for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) {
14047      composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i);
14048    }
14049    if (element.hasType()) {
14050      composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1);
14051    }
14052    if (element.hasQuantity()) {
14053      composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1);
14054    }
14055    if (element.hasDaysSupply()) {
14056      composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1);
14057    }
14058    if (element.hasWhenPreparedElement()) {
14059      composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1);
14060    }
14061    if (element.hasWhenHandedOverElement()) {
14062      composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1);
14063    }
14064    if (element.hasDestination()) {
14065      composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1);
14066    }
14067    for (int i = 0; i < element.getReceiver().size(); i++) {
14068      composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i);
14069    }
14070    for (int i = 0; i < element.getNote().size(); i++) {
14071      composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i);
14072    }
14073    if (element.hasRenderedDosageInstructionElement()) {
14074      composeString(t, "MedicationDispense", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1);
14075    }
14076    for (int i = 0; i < element.getDosageInstruction().size(); i++) {
14077      composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i);
14078    }
14079    if (element.hasSubstitution()) {
14080      composeMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1);
14081    }
14082    for (int i = 0; i < element.getDetectedIssue().size(); i++) {
14083      composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i);
14084    }
14085    for (int i = 0; i < element.getEventHistory().size(); i++) {
14086      composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i);
14087    }
14088  }
14089
14090  protected void composeMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) {
14091    if (element == null) 
14092      return;
14093    Complex t;
14094    if (Utilities.noString(parentType))
14095      t = parent;
14096    else {
14097      t = parent.predicate("fhir:"+parentType+'.'+name);
14098    }
14099    composeBackboneElement(t, "performer", name, element, index);
14100    if (element.hasFunction()) {
14101      composeCodeableConcept(t, "MedicationDispensePerformerComponent", "function", element.getFunction(), -1);
14102    }
14103    if (element.hasActor()) {
14104      composeReference(t, "MedicationDispensePerformerComponent", "actor", element.getActor(), -1);
14105    }
14106  }
14107
14108  protected void composeMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) {
14109    if (element == null) 
14110      return;
14111    Complex t;
14112    if (Utilities.noString(parentType))
14113      t = parent;
14114    else {
14115      t = parent.predicate("fhir:"+parentType+'.'+name);
14116    }
14117    composeBackboneElement(t, "substitution", name, element, index);
14118    if (element.hasWasSubstitutedElement()) {
14119      composeBoolean(t, "MedicationDispenseSubstitutionComponent", "wasSubstituted", element.getWasSubstitutedElement(), -1);
14120    }
14121    if (element.hasType()) {
14122      composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "type", element.getType(), -1);
14123    }
14124    for (int i = 0; i < element.getReason().size(); i++) {
14125      composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "reason", element.getReason().get(i), i);
14126    }
14127    if (element.hasResponsibleParty()) {
14128      composeReference(t, "MedicationDispenseSubstitutionComponent", "responsibleParty", element.getResponsibleParty(), -1);
14129    }
14130  }
14131
14132  protected void composeMedicationKnowledge(Complex parent, String parentType, String name, MedicationKnowledge element, int index) {
14133    if (element == null) 
14134      return;
14135    Complex t;
14136    if (Utilities.noString(parentType))
14137      t = parent;
14138    else {
14139      t = parent.predicate("fhir:"+parentType+'.'+name);
14140    }
14141    composeDomainResource(t, "MedicationKnowledge", name, element, index);
14142    for (int i = 0; i < element.getIdentifier().size(); i++) {
14143      composeIdentifier(t, "MedicationKnowledge", "identifier", element.getIdentifier().get(i), i);
14144    }
14145    if (element.hasCode()) {
14146      composeCodeableConcept(t, "MedicationKnowledge", "code", element.getCode(), -1);
14147    }
14148    if (element.hasStatusElement()) {
14149      composeEnum(t, "MedicationKnowledge", "status", element.getStatusElement(), -1);
14150    }
14151    if (element.hasManufacturer()) {
14152      composeReference(t, "MedicationKnowledge", "manufacturer", element.getManufacturer(), -1);
14153    }
14154    if (element.hasDoseForm()) {
14155      composeCodeableConcept(t, "MedicationKnowledge", "doseForm", element.getDoseForm(), -1);
14156    }
14157    if (element.hasAmount()) {
14158      composeQuantity(t, "MedicationKnowledge", "amount", element.getAmount(), -1);
14159    }
14160    for (int i = 0; i < element.getSynonym().size(); i++) {
14161      composeString(t, "MedicationKnowledge", "synonym", element.getSynonym().get(i), i);
14162    }
14163    for (int i = 0; i < element.getRelatedMedicationKnowledge().size(); i++) {
14164      composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(t, "MedicationKnowledge", "relatedMedicationKnowledge", element.getRelatedMedicationKnowledge().get(i), i);
14165    }
14166    for (int i = 0; i < element.getAssociatedMedication().size(); i++) {
14167      composeReference(t, "MedicationKnowledge", "associatedMedication", element.getAssociatedMedication().get(i), i);
14168    }
14169    for (int i = 0; i < element.getProductType().size(); i++) {
14170      composeCodeableConcept(t, "MedicationKnowledge", "productType", element.getProductType().get(i), i);
14171    }
14172    for (int i = 0; i < element.getMonograph().size(); i++) {
14173      composeMedicationKnowledgeMonographComponent(t, "MedicationKnowledge", "monograph", element.getMonograph().get(i), i);
14174    }
14175    for (int i = 0; i < element.getIngredient().size(); i++) {
14176      composeMedicationKnowledgeIngredientComponent(t, "MedicationKnowledge", "ingredient", element.getIngredient().get(i), i);
14177    }
14178    for (int i = 0; i < element.getDevice().size(); i++) {
14179      composeReference(t, "MedicationKnowledge", "device", element.getDevice().get(i), i);
14180    }
14181    if (element.hasPreparationInstructionElement()) {
14182      composeMarkdown(t, "MedicationKnowledge", "preparationInstruction", element.getPreparationInstructionElement(), -1);
14183    }
14184    for (int i = 0; i < element.getIntendedRoute().size(); i++) {
14185      composeCodeableConcept(t, "MedicationKnowledge", "intendedRoute", element.getIntendedRoute().get(i), i);
14186    }
14187    for (int i = 0; i < element.getCost().size(); i++) {
14188      composeMedicationKnowledgeCostComponent(t, "MedicationKnowledge", "cost", element.getCost().get(i), i);
14189    }
14190    for (int i = 0; i < element.getMonitoringProgram().size(); i++) {
14191      composeMedicationKnowledgeMonitoringProgramComponent(t, "MedicationKnowledge", "monitoringProgram", element.getMonitoringProgram().get(i), i);
14192    }
14193    for (int i = 0; i < element.getAdministrationGuideline().size(); i++) {
14194      composeMedicationKnowledgeAdministrationGuidelineComponent(t, "MedicationKnowledge", "administrationGuideline", element.getAdministrationGuideline().get(i), i);
14195    }
14196    for (int i = 0; i < element.getMedicineClassification().size(); i++) {
14197      composeMedicationKnowledgeMedicineClassificationComponent(t, "MedicationKnowledge", "medicineClassification", element.getMedicineClassification().get(i), i);
14198    }
14199    if (element.hasPackaging()) {
14200      composeMedicationKnowledgePackagingComponent(t, "MedicationKnowledge", "packaging", element.getPackaging(), -1);
14201    }
14202    for (int i = 0; i < element.getDrugCharacteristic().size(); i++) {
14203      composeMedicationKnowledgeDrugCharacteristicComponent(t, "MedicationKnowledge", "drugCharacteristic", element.getDrugCharacteristic().get(i), i);
14204    }
14205    for (int i = 0; i < element.getClinicalUseIssue().size(); i++) {
14206      composeReference(t, "MedicationKnowledge", "clinicalUseIssue", element.getClinicalUseIssue().get(i), i);
14207    }
14208    for (int i = 0; i < element.getRegulatory().size(); i++) {
14209      composeMedicationKnowledgeRegulatoryComponent(t, "MedicationKnowledge", "regulatory", element.getRegulatory().get(i), i);
14210    }
14211    for (int i = 0; i < element.getKineticCharacteristic().size(); i++) {
14212      composeMedicationKnowledgeKineticCharacteristicComponent(t, "MedicationKnowledge", "kineticCharacteristic", element.getKineticCharacteristic().get(i), i);
14213    }
14214  }
14215
14216  protected void composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRelatedMedicationKnowledgeComponent element, int index) {
14217    if (element == null) 
14218      return;
14219    Complex t;
14220    if (Utilities.noString(parentType))
14221      t = parent;
14222    else {
14223      t = parent.predicate("fhir:"+parentType+'.'+name);
14224    }
14225    composeBackboneElement(t, "relatedMedicationKnowledge", name, element, index);
14226    if (element.hasType()) {
14227      composeCodeableConcept(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "type", element.getType(), -1);
14228    }
14229    for (int i = 0; i < element.getReference().size(); i++) {
14230      composeReference(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "reference", element.getReference().get(i), i);
14231    }
14232  }
14233
14234  protected void composeMedicationKnowledgeMonographComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonographComponent element, int index) {
14235    if (element == null) 
14236      return;
14237    Complex t;
14238    if (Utilities.noString(parentType))
14239      t = parent;
14240    else {
14241      t = parent.predicate("fhir:"+parentType+'.'+name);
14242    }
14243    composeBackboneElement(t, "monograph", name, element, index);
14244    if (element.hasType()) {
14245      composeCodeableConcept(t, "MedicationKnowledgeMonographComponent", "type", element.getType(), -1);
14246    }
14247    if (element.hasSource()) {
14248      composeReference(t, "MedicationKnowledgeMonographComponent", "source", element.getSource(), -1);
14249    }
14250  }
14251
14252  protected void composeMedicationKnowledgeIngredientComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIngredientComponent element, int index) {
14253    if (element == null) 
14254      return;
14255    Complex t;
14256    if (Utilities.noString(parentType))
14257      t = parent;
14258    else {
14259      t = parent.predicate("fhir:"+parentType+'.'+name);
14260    }
14261    composeBackboneElement(t, "ingredient", name, element, index);
14262    if (element.hasItem()) {
14263      composeType(t, "MedicationKnowledgeIngredientComponent", "item", element.getItem(), -1);
14264    }
14265    if (element.hasIsActiveElement()) {
14266      composeBoolean(t, "MedicationKnowledgeIngredientComponent", "isActive", element.getIsActiveElement(), -1);
14267    }
14268    if (element.hasStrength()) {
14269      composeType(t, "MedicationKnowledgeIngredientComponent", "strength", element.getStrength(), -1);
14270    }
14271  }
14272
14273  protected void composeMedicationKnowledgeCostComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeCostComponent element, int index) {
14274    if (element == null) 
14275      return;
14276    Complex t;
14277    if (Utilities.noString(parentType))
14278      t = parent;
14279    else {
14280      t = parent.predicate("fhir:"+parentType+'.'+name);
14281    }
14282    composeBackboneElement(t, "cost", name, element, index);
14283    if (element.hasType()) {
14284      composeCodeableConcept(t, "MedicationKnowledgeCostComponent", "type", element.getType(), -1);
14285    }
14286    if (element.hasSourceElement()) {
14287      composeString(t, "MedicationKnowledgeCostComponent", "source", element.getSourceElement(), -1);
14288    }
14289    if (element.hasCost()) {
14290      composeMoney(t, "MedicationKnowledgeCostComponent", "cost", element.getCost(), -1);
14291    }
14292  }
14293
14294  protected void composeMedicationKnowledgeMonitoringProgramComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonitoringProgramComponent element, int index) {
14295    if (element == null) 
14296      return;
14297    Complex t;
14298    if (Utilities.noString(parentType))
14299      t = parent;
14300    else {
14301      t = parent.predicate("fhir:"+parentType+'.'+name);
14302    }
14303    composeBackboneElement(t, "monitoringProgram", name, element, index);
14304    if (element.hasType()) {
14305      composeCodeableConcept(t, "MedicationKnowledgeMonitoringProgramComponent", "type", element.getType(), -1);
14306    }
14307    if (element.hasNameElement()) {
14308      composeString(t, "MedicationKnowledgeMonitoringProgramComponent", "name", element.getNameElement(), -1);
14309    }
14310  }
14311
14312  protected void composeMedicationKnowledgeAdministrationGuidelineComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelineComponent element, int index) {
14313    if (element == null) 
14314      return;
14315    Complex t;
14316    if (Utilities.noString(parentType))
14317      t = parent;
14318    else {
14319      t = parent.predicate("fhir:"+parentType+'.'+name);
14320    }
14321    composeBackboneElement(t, "administrationGuideline", name, element, index);
14322    for (int i = 0; i < element.getDosage().size(); i++) {
14323      composeMedicationKnowledgeAdministrationGuidelineDosageComponent(t, "MedicationKnowledgeAdministrationGuidelineComponent", "dosage", element.getDosage().get(i), i);
14324    }
14325    if (element.hasIndication()) {
14326      composeType(t, "MedicationKnowledgeAdministrationGuidelineComponent", "indication", element.getIndication(), -1);
14327    }
14328    for (int i = 0; i < element.getPatientCharacteristic().size(); i++) {
14329      composeMedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent(t, "MedicationKnowledgeAdministrationGuidelineComponent", "patientCharacteristic", element.getPatientCharacteristic().get(i), i);
14330    }
14331  }
14332
14333  protected void composeMedicationKnowledgeAdministrationGuidelineDosageComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelineDosageComponent element, int index) {
14334    if (element == null) 
14335      return;
14336    Complex t;
14337    if (Utilities.noString(parentType))
14338      t = parent;
14339    else {
14340      t = parent.predicate("fhir:"+parentType+'.'+name);
14341    }
14342    composeBackboneElement(t, "dosage", name, element, index);
14343    if (element.hasType()) {
14344      composeCodeableConcept(t, "MedicationKnowledgeAdministrationGuidelineDosageComponent", "type", element.getType(), -1);
14345    }
14346    for (int i = 0; i < element.getDosage().size(); i++) {
14347      composeDosage(t, "MedicationKnowledgeAdministrationGuidelineDosageComponent", "dosage", element.getDosage().get(i), i);
14348    }
14349  }
14350
14351  protected void composeMedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent element, int index) {
14352    if (element == null) 
14353      return;
14354    Complex t;
14355    if (Utilities.noString(parentType))
14356      t = parent;
14357    else {
14358      t = parent.predicate("fhir:"+parentType+'.'+name);
14359    }
14360    composeBackboneElement(t, "patientCharacteristic", name, element, index);
14361    if (element.hasCharacteristic()) {
14362      composeType(t, "MedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent", "characteristic", element.getCharacteristic(), -1);
14363    }
14364    for (int i = 0; i < element.getValue().size(); i++) {
14365      composeString(t, "MedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent", "value", element.getValue().get(i), i);
14366    }
14367  }
14368
14369  protected void composeMedicationKnowledgeMedicineClassificationComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMedicineClassificationComponent element, int index) {
14370    if (element == null) 
14371      return;
14372    Complex t;
14373    if (Utilities.noString(parentType))
14374      t = parent;
14375    else {
14376      t = parent.predicate("fhir:"+parentType+'.'+name);
14377    }
14378    composeBackboneElement(t, "medicineClassification", name, element, index);
14379    if (element.hasType()) {
14380      composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "type", element.getType(), -1);
14381    }
14382    for (int i = 0; i < element.getClassification().size(); i++) {
14383      composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "classification", element.getClassification().get(i), i);
14384    }
14385  }
14386
14387  protected void composeMedicationKnowledgePackagingComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgePackagingComponent element, int index) {
14388    if (element == null) 
14389      return;
14390    Complex t;
14391    if (Utilities.noString(parentType))
14392      t = parent;
14393    else {
14394      t = parent.predicate("fhir:"+parentType+'.'+name);
14395    }
14396    composeBackboneElement(t, "packaging", name, element, index);
14397    if (element.hasType()) {
14398      composeCodeableConcept(t, "MedicationKnowledgePackagingComponent", "type", element.getType(), -1);
14399    }
14400    if (element.hasQuantity()) {
14401      composeQuantity(t, "MedicationKnowledgePackagingComponent", "quantity", element.getQuantity(), -1);
14402    }
14403    if (element.hasDevice()) {
14404      composeReference(t, "MedicationKnowledgePackagingComponent", "device", element.getDevice(), -1);
14405    }
14406    if (element.hasMaterial()) {
14407      composeCodeableConcept(t, "MedicationKnowledgePackagingComponent", "material", element.getMaterial(), -1);
14408    }
14409    for (int i = 0; i < element.getPackaging().size(); i++) {
14410      composeMedicationKnowledgePackagingComponent(t, "MedicationKnowledgePackagingComponent", "packaging", element.getPackaging().get(i), i);
14411    }
14412  }
14413
14414  protected void composeMedicationKnowledgeDrugCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeDrugCharacteristicComponent element, int index) {
14415    if (element == null) 
14416      return;
14417    Complex t;
14418    if (Utilities.noString(parentType))
14419      t = parent;
14420    else {
14421      t = parent.predicate("fhir:"+parentType+'.'+name);
14422    }
14423    composeBackboneElement(t, "drugCharacteristic", name, element, index);
14424    if (element.hasType()) {
14425      composeCodeableConcept(t, "MedicationKnowledgeDrugCharacteristicComponent", "type", element.getType(), -1);
14426    }
14427    if (element.hasValue()) {
14428      composeType(t, "MedicationKnowledgeDrugCharacteristicComponent", "value", element.getValue(), -1);
14429    }
14430  }
14431
14432  protected void composeMedicationKnowledgeRegulatoryComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryComponent element, int index) {
14433    if (element == null) 
14434      return;
14435    Complex t;
14436    if (Utilities.noString(parentType))
14437      t = parent;
14438    else {
14439      t = parent.predicate("fhir:"+parentType+'.'+name);
14440    }
14441    composeBackboneElement(t, "regulatory", name, element, index);
14442    if (element.hasRegulatoryAuthority()) {
14443      composeReference(t, "MedicationKnowledgeRegulatoryComponent", "regulatoryAuthority", element.getRegulatoryAuthority(), -1);
14444    }
14445    for (int i = 0; i < element.getSubstitution().size(); i++) {
14446      composeMedicationKnowledgeRegulatorySubstitutionComponent(t, "MedicationKnowledgeRegulatoryComponent", "substitution", element.getSubstitution().get(i), i);
14447    }
14448    for (int i = 0; i < element.getSchedule().size(); i++) {
14449      composeCodeableConcept(t, "MedicationKnowledgeRegulatoryComponent", "schedule", element.getSchedule().get(i), i);
14450    }
14451    if (element.hasMaxDispense()) {
14452      composeMedicationKnowledgeRegulatoryMaxDispenseComponent(t, "MedicationKnowledgeRegulatoryComponent", "maxDispense", element.getMaxDispense(), -1);
14453    }
14454  }
14455
14456  protected void composeMedicationKnowledgeRegulatorySubstitutionComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatorySubstitutionComponent element, int index) {
14457    if (element == null) 
14458      return;
14459    Complex t;
14460    if (Utilities.noString(parentType))
14461      t = parent;
14462    else {
14463      t = parent.predicate("fhir:"+parentType+'.'+name);
14464    }
14465    composeBackboneElement(t, "substitution", name, element, index);
14466    if (element.hasType()) {
14467      composeCodeableConcept(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "type", element.getType(), -1);
14468    }
14469    if (element.hasAllowedElement()) {
14470      composeBoolean(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "allowed", element.getAllowedElement(), -1);
14471    }
14472  }
14473
14474  protected void composeMedicationKnowledgeRegulatoryMaxDispenseComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryMaxDispenseComponent element, int index) {
14475    if (element == null) 
14476      return;
14477    Complex t;
14478    if (Utilities.noString(parentType))
14479      t = parent;
14480    else {
14481      t = parent.predicate("fhir:"+parentType+'.'+name);
14482    }
14483    composeBackboneElement(t, "maxDispense", name, element, index);
14484    if (element.hasQuantity()) {
14485      composeQuantity(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "quantity", element.getQuantity(), -1);
14486    }
14487    if (element.hasPeriod()) {
14488      composeDuration(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "period", element.getPeriod(), -1);
14489    }
14490  }
14491
14492  protected void composeMedicationKnowledgeKineticCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeKineticCharacteristicComponent element, int index) {
14493    if (element == null) 
14494      return;
14495    Complex t;
14496    if (Utilities.noString(parentType))
14497      t = parent;
14498    else {
14499      t = parent.predicate("fhir:"+parentType+'.'+name);
14500    }
14501    composeBackboneElement(t, "kineticCharacteristic", name, element, index);
14502    if (element.hasType()) {
14503      composeCodeableConcept(t, "MedicationKnowledgeKineticCharacteristicComponent", "type", element.getType(), -1);
14504    }
14505    if (element.hasValue()) {
14506      composeType(t, "MedicationKnowledgeKineticCharacteristicComponent", "value", element.getValue(), -1);
14507    }
14508  }
14509
14510  protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest element, int index) {
14511    if (element == null) 
14512      return;
14513    Complex t;
14514    if (Utilities.noString(parentType))
14515      t = parent;
14516    else {
14517      t = parent.predicate("fhir:"+parentType+'.'+name);
14518    }
14519    composeDomainResource(t, "MedicationRequest", name, element, index);
14520    for (int i = 0; i < element.getIdentifier().size(); i++) {
14521      composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i);
14522    }
14523    if (element.hasStatusElement()) {
14524      composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1);
14525    }
14526    if (element.hasStatusReason()) {
14527      composeCodeableConcept(t, "MedicationRequest", "statusReason", element.getStatusReason(), -1);
14528    }
14529    if (element.hasIntentElement()) {
14530      composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1);
14531    }
14532    for (int i = 0; i < element.getCategory().size(); i++) {
14533      composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory().get(i), i);
14534    }
14535    if (element.hasPriorityElement()) {
14536      composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1);
14537    }
14538    if (element.hasDoNotPerformElement()) {
14539      composeBoolean(t, "MedicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
14540    }
14541    if (element.hasReportedElement()) {
14542      composeBoolean(t, "MedicationRequest", "reported", element.getReportedElement(), -1);
14543    }
14544    if (element.hasInformationSource()) {
14545      composeReference(t, "MedicationRequest", "informationSource", element.getInformationSource(), -1);
14546    }
14547    if (element.hasMedication()) {
14548      composeType(t, "MedicationRequest", "medication", element.getMedication(), -1);
14549    }
14550    if (element.hasSubject()) {
14551      composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1);
14552    }
14553    if (element.hasEncounter()) {
14554      composeReference(t, "MedicationRequest", "encounter", element.getEncounter(), -1);
14555    }
14556    for (int i = 0; i < element.getSupportingInformation().size(); i++) {
14557      composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i);
14558    }
14559    if (element.hasAuthoredOnElement()) {
14560      composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1);
14561    }
14562    if (element.hasRequester()) {
14563      composeReference(t, "MedicationRequest", "requester", element.getRequester(), -1);
14564    }
14565    if (element.hasPerformer()) {
14566      composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1);
14567    }
14568    if (element.hasPerformerType()) {
14569      composeCodeableConcept(t, "MedicationRequest", "performerType", element.getPerformerType(), -1);
14570    }
14571    if (element.hasRecorder()) {
14572      composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1);
14573    }
14574    for (int i = 0; i < element.getReason().size(); i++) {
14575      composeCodeableReference(t, "MedicationRequest", "reason", element.getReason().get(i), i);
14576    }
14577    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
14578      composeCanonical(t, "MedicationRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
14579    }
14580    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
14581      composeUri(t, "MedicationRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
14582    }
14583    for (int i = 0; i < element.getBasedOn().size(); i++) {
14584      composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i);
14585    }
14586    if (element.hasGroupIdentifier()) {
14587      composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1);
14588    }
14589    if (element.hasCourseOfTherapyType()) {
14590      composeCodeableConcept(t, "MedicationRequest", "courseOfTherapyType", element.getCourseOfTherapyType(), -1);
14591    }
14592    for (int i = 0; i < element.getInsurance().size(); i++) {
14593      composeReference(t, "MedicationRequest", "insurance", element.getInsurance().get(i), i);
14594    }
14595    for (int i = 0; i < element.getNote().size(); i++) {
14596      composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i);
14597    }
14598    if (element.hasRenderedDosageInstructionElement()) {
14599      composeString(t, "MedicationRequest", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1);
14600    }
14601    for (int i = 0; i < element.getDosageInstruction().size(); i++) {
14602      composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i);
14603    }
14604    if (element.hasDispenseRequest()) {
14605      composeMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1);
14606    }
14607    if (element.hasSubstitution()) {
14608      composeMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1);
14609    }
14610    if (element.hasPriorPrescription()) {
14611      composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1);
14612    }
14613    for (int i = 0; i < element.getDetectedIssue().size(); i++) {
14614      composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i);
14615    }
14616    for (int i = 0; i < element.getEventHistory().size(); i++) {
14617      composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i);
14618    }
14619  }
14620
14621  protected void composeMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) {
14622    if (element == null) 
14623      return;
14624    Complex t;
14625    if (Utilities.noString(parentType))
14626      t = parent;
14627    else {
14628      t = parent.predicate("fhir:"+parentType+'.'+name);
14629    }
14630    composeBackboneElement(t, "dispenseRequest", name, element, index);
14631    if (element.hasInitialFill()) {
14632      composeMedicationRequestDispenseRequestInitialFillComponent(t, "MedicationRequestDispenseRequestComponent", "initialFill", element.getInitialFill(), -1);
14633    }
14634    if (element.hasDispenseInterval()) {
14635      composeDuration(t, "MedicationRequestDispenseRequestComponent", "dispenseInterval", element.getDispenseInterval(), -1);
14636    }
14637    if (element.hasValidityPeriod()) {
14638      composePeriod(t, "MedicationRequestDispenseRequestComponent", "validityPeriod", element.getValidityPeriod(), -1);
14639    }
14640    if (element.hasNumberOfRepeatsAllowedElement()) {
14641      composeUnsignedInt(t, "MedicationRequestDispenseRequestComponent", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1);
14642    }
14643    if (element.hasQuantity()) {
14644      composeQuantity(t, "MedicationRequestDispenseRequestComponent", "quantity", element.getQuantity(), -1);
14645    }
14646    if (element.hasExpectedSupplyDuration()) {
14647      composeDuration(t, "MedicationRequestDispenseRequestComponent", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1);
14648    }
14649    if (element.hasDispenser()) {
14650      composeReference(t, "MedicationRequestDispenseRequestComponent", "dispenser", element.getDispenser(), -1);
14651    }
14652  }
14653
14654  protected void composeMedicationRequestDispenseRequestInitialFillComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestInitialFillComponent element, int index) {
14655    if (element == null) 
14656      return;
14657    Complex t;
14658    if (Utilities.noString(parentType))
14659      t = parent;
14660    else {
14661      t = parent.predicate("fhir:"+parentType+'.'+name);
14662    }
14663    composeBackboneElement(t, "initialFill", name, element, index);
14664    if (element.hasQuantity()) {
14665      composeQuantity(t, "MedicationRequestDispenseRequestInitialFillComponent", "quantity", element.getQuantity(), -1);
14666    }
14667    if (element.hasDuration()) {
14668      composeDuration(t, "MedicationRequestDispenseRequestInitialFillComponent", "duration", element.getDuration(), -1);
14669    }
14670  }
14671
14672  protected void composeMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) {
14673    if (element == null) 
14674      return;
14675    Complex t;
14676    if (Utilities.noString(parentType))
14677      t = parent;
14678    else {
14679      t = parent.predicate("fhir:"+parentType+'.'+name);
14680    }
14681    composeBackboneElement(t, "substitution", name, element, index);
14682    if (element.hasAllowed()) {
14683      composeType(t, "MedicationRequestSubstitutionComponent", "allowed", element.getAllowed(), -1);
14684    }
14685    if (element.hasReason()) {
14686      composeCodeableConcept(t, "MedicationRequestSubstitutionComponent", "reason", element.getReason(), -1);
14687    }
14688  }
14689
14690  protected void composeMedicationUsage(Complex parent, String parentType, String name, MedicationUsage element, int index) {
14691    if (element == null) 
14692      return;
14693    Complex t;
14694    if (Utilities.noString(parentType))
14695      t = parent;
14696    else {
14697      t = parent.predicate("fhir:"+parentType+'.'+name);
14698    }
14699    composeDomainResource(t, "MedicationUsage", name, element, index);
14700    for (int i = 0; i < element.getIdentifier().size(); i++) {
14701      composeIdentifier(t, "MedicationUsage", "identifier", element.getIdentifier().get(i), i);
14702    }
14703    for (int i = 0; i < element.getBasedOn().size(); i++) {
14704      composeReference(t, "MedicationUsage", "basedOn", element.getBasedOn().get(i), i);
14705    }
14706    for (int i = 0; i < element.getPartOf().size(); i++) {
14707      composeReference(t, "MedicationUsage", "partOf", element.getPartOf().get(i), i);
14708    }
14709    if (element.hasStatusElement()) {
14710      composeEnum(t, "MedicationUsage", "status", element.getStatusElement(), -1);
14711    }
14712    for (int i = 0; i < element.getStatusReason().size(); i++) {
14713      composeCodeableConcept(t, "MedicationUsage", "statusReason", element.getStatusReason().get(i), i);
14714    }
14715    for (int i = 0; i < element.getCategory().size(); i++) {
14716      composeCodeableConcept(t, "MedicationUsage", "category", element.getCategory().get(i), i);
14717    }
14718    if (element.hasMedication()) {
14719      composeType(t, "MedicationUsage", "medication", element.getMedication(), -1);
14720    }
14721    if (element.hasSubject()) {
14722      composeReference(t, "MedicationUsage", "subject", element.getSubject(), -1);
14723    }
14724    if (element.hasEncounter()) {
14725      composeReference(t, "MedicationUsage", "encounter", element.getEncounter(), -1);
14726    }
14727    if (element.hasEffective()) {
14728      composeType(t, "MedicationUsage", "effective", element.getEffective(), -1);
14729    }
14730    if (element.hasDateAssertedElement()) {
14731      composeDateTime(t, "MedicationUsage", "dateAsserted", element.getDateAssertedElement(), -1);
14732    }
14733    if (element.hasInformationSource()) {
14734      composeReference(t, "MedicationUsage", "informationSource", element.getInformationSource(), -1);
14735    }
14736    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
14737      composeReference(t, "MedicationUsage", "derivedFrom", element.getDerivedFrom().get(i), i);
14738    }
14739    for (int i = 0; i < element.getReason().size(); i++) {
14740      composeCodeableReference(t, "MedicationUsage", "reason", element.getReason().get(i), i);
14741    }
14742    for (int i = 0; i < element.getNote().size(); i++) {
14743      composeAnnotation(t, "MedicationUsage", "note", element.getNote().get(i), i);
14744    }
14745    if (element.hasRenderedDosageInstructionElement()) {
14746      composeString(t, "MedicationUsage", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1);
14747    }
14748    for (int i = 0; i < element.getDosage().size(); i++) {
14749      composeDosage(t, "MedicationUsage", "dosage", element.getDosage().get(i), i);
14750    }
14751    if (element.hasTakenAsOrderedElement()) {
14752      composeBoolean(t, "MedicationUsage", "takenAsOrdered", element.getTakenAsOrderedElement(), -1);
14753    }
14754  }
14755
14756  protected void composeMedicinalProductDefinition(Complex parent, String parentType, String name, MedicinalProductDefinition element, int index) {
14757    if (element == null) 
14758      return;
14759    Complex t;
14760    if (Utilities.noString(parentType))
14761      t = parent;
14762    else {
14763      t = parent.predicate("fhir:"+parentType+'.'+name);
14764    }
14765    composeDomainResource(t, "MedicinalProductDefinition", name, element, index);
14766    for (int i = 0; i < element.getIdentifier().size(); i++) {
14767      composeIdentifier(t, "MedicinalProductDefinition", "identifier", element.getIdentifier().get(i), i);
14768    }
14769    if (element.hasType()) {
14770      composeCodeableConcept(t, "MedicinalProductDefinition", "type", element.getType(), -1);
14771    }
14772    if (element.hasDomain()) {
14773      composeCoding(t, "MedicinalProductDefinition", "domain", element.getDomain(), -1);
14774    }
14775    if (element.hasVersionElement()) {
14776      composeString(t, "MedicinalProductDefinition", "version", element.getVersionElement(), -1);
14777    }
14778    if (element.hasStatus()) {
14779      composeCoding(t, "MedicinalProductDefinition", "status", element.getStatus(), -1);
14780    }
14781    if (element.hasDescriptionElement()) {
14782      composeMarkdown(t, "MedicinalProductDefinition", "description", element.getDescriptionElement(), -1);
14783    }
14784    if (element.hasCombinedPharmaceuticalDoseForm()) {
14785      composeCodeableConcept(t, "MedicinalProductDefinition", "combinedPharmaceuticalDoseForm", element.getCombinedPharmaceuticalDoseForm(), -1);
14786    }
14787    if (element.hasIndicationElement()) {
14788      composeMarkdown(t, "MedicinalProductDefinition", "indication", element.getIndicationElement(), -1);
14789    }
14790    if (element.hasLegalStatusOfSupply()) {
14791      composeCodeableConcept(t, "MedicinalProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1);
14792    }
14793    if (element.hasAdditionalMonitoringIndicator()) {
14794      composeCodeableConcept(t, "MedicinalProductDefinition", "additionalMonitoringIndicator", element.getAdditionalMonitoringIndicator(), -1);
14795    }
14796    for (int i = 0; i < element.getSpecialMeasures().size(); i++) {
14797      composeCodeableConcept(t, "MedicinalProductDefinition", "specialMeasures", element.getSpecialMeasures().get(i), i);
14798    }
14799    if (element.hasPaediatricUseIndicator()) {
14800      composeCodeableConcept(t, "MedicinalProductDefinition", "paediatricUseIndicator", element.getPaediatricUseIndicator(), -1);
14801    }
14802    for (int i = 0; i < element.getProductClassification().size(); i++) {
14803      composeCodeableConcept(t, "MedicinalProductDefinition", "productClassification", element.getProductClassification().get(i), i);
14804    }
14805    for (int i = 0; i < element.getMarketingStatus().size(); i++) {
14806      composeMarketingStatus(t, "MedicinalProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i);
14807    }
14808    for (int i = 0; i < element.getPharmaceuticalProduct().size(); i++) {
14809      composeReference(t, "MedicinalProductDefinition", "pharmaceuticalProduct", element.getPharmaceuticalProduct().get(i), i);
14810    }
14811    for (int i = 0; i < element.getPackagedMedicinalProduct().size(); i++) {
14812      composeReference(t, "MedicinalProductDefinition", "packagedMedicinalProduct", element.getPackagedMedicinalProduct().get(i), i);
14813    }
14814    for (int i = 0; i < element.getIngredient().size(); i++) {
14815      composeReference(t, "MedicinalProductDefinition", "ingredient", element.getIngredient().get(i), i);
14816    }
14817    for (int i = 0; i < element.getAttachedDocument().size(); i++) {
14818      composeReference(t, "MedicinalProductDefinition", "attachedDocument", element.getAttachedDocument().get(i), i);
14819    }
14820    for (int i = 0; i < element.getMasterFile().size(); i++) {
14821      composeReference(t, "MedicinalProductDefinition", "masterFile", element.getMasterFile().get(i), i);
14822    }
14823    for (int i = 0; i < element.getContact().size(); i++) {
14824      composeMedicinalProductDefinitionContactComponent(t, "MedicinalProductDefinition", "contact", element.getContact().get(i), i);
14825    }
14826    for (int i = 0; i < element.getClinicalTrial().size(); i++) {
14827      composeReference(t, "MedicinalProductDefinition", "clinicalTrial", element.getClinicalTrial().get(i), i);
14828    }
14829    for (int i = 0; i < element.getName().size(); i++) {
14830      composeMedicinalProductDefinitionNameComponent(t, "MedicinalProductDefinition", "name", element.getName().get(i), i);
14831    }
14832    for (int i = 0; i < element.getCrossReference().size(); i++) {
14833      composeMedicinalProductDefinitionCrossReferenceComponent(t, "MedicinalProductDefinition", "crossReference", element.getCrossReference().get(i), i);
14834    }
14835    for (int i = 0; i < element.getManufacturingBusinessOperation().size(); i++) {
14836      composeMedicinalProductDefinitionManufacturingBusinessOperationComponent(t, "MedicinalProductDefinition", "manufacturingBusinessOperation", element.getManufacturingBusinessOperation().get(i), i);
14837    }
14838  }
14839
14840  protected void composeMedicinalProductDefinitionContactComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionContactComponent element, int index) {
14841    if (element == null) 
14842      return;
14843    Complex t;
14844    if (Utilities.noString(parentType))
14845      t = parent;
14846    else {
14847      t = parent.predicate("fhir:"+parentType+'.'+name);
14848    }
14849    composeBackboneElement(t, "contact", name, element, index);
14850    if (element.hasType()) {
14851      composeCodeableConcept(t, "MedicinalProductDefinitionContactComponent", "type", element.getType(), -1);
14852    }
14853    if (element.hasContact()) {
14854      composeReference(t, "MedicinalProductDefinitionContactComponent", "contact", element.getContact(), -1);
14855    }
14856  }
14857
14858  protected void composeMedicinalProductDefinitionNameComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameComponent element, int index) {
14859    if (element == null) 
14860      return;
14861    Complex t;
14862    if (Utilities.noString(parentType))
14863      t = parent;
14864    else {
14865      t = parent.predicate("fhir:"+parentType+'.'+name);
14866    }
14867    composeBackboneElement(t, "name", name, element, index);
14868    if (element.hasProductNameElement()) {
14869      composeString(t, "MedicinalProductDefinitionNameComponent", "productName", element.getProductNameElement(), -1);
14870    }
14871    if (element.hasType()) {
14872      composeCoding(t, "MedicinalProductDefinitionNameComponent", "type", element.getType(), -1);
14873    }
14874    for (int i = 0; i < element.getNamePart().size(); i++) {
14875      composeMedicinalProductDefinitionNameNamePartComponent(t, "MedicinalProductDefinitionNameComponent", "namePart", element.getNamePart().get(i), i);
14876    }
14877    for (int i = 0; i < element.getCountryLanguage().size(); i++) {
14878      composeMedicinalProductDefinitionNameCountryLanguageComponent(t, "MedicinalProductDefinitionNameComponent", "countryLanguage", element.getCountryLanguage().get(i), i);
14879    }
14880  }
14881
14882  protected void composeMedicinalProductDefinitionNameNamePartComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameNamePartComponent element, int index) {
14883    if (element == null) 
14884      return;
14885    Complex t;
14886    if (Utilities.noString(parentType))
14887      t = parent;
14888    else {
14889      t = parent.predicate("fhir:"+parentType+'.'+name);
14890    }
14891    composeBackboneElement(t, "namePart", name, element, index);
14892    if (element.hasPartElement()) {
14893      composeString(t, "MedicinalProductDefinitionNameNamePartComponent", "part", element.getPartElement(), -1);
14894    }
14895    if (element.hasType()) {
14896      composeCoding(t, "MedicinalProductDefinitionNameNamePartComponent", "type", element.getType(), -1);
14897    }
14898  }
14899
14900  protected void composeMedicinalProductDefinitionNameCountryLanguageComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameCountryLanguageComponent element, int index) {
14901    if (element == null) 
14902      return;
14903    Complex t;
14904    if (Utilities.noString(parentType))
14905      t = parent;
14906    else {
14907      t = parent.predicate("fhir:"+parentType+'.'+name);
14908    }
14909    composeBackboneElement(t, "countryLanguage", name, element, index);
14910    if (element.hasCountry()) {
14911      composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "country", element.getCountry(), -1);
14912    }
14913    if (element.hasJurisdiction()) {
14914      composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "jurisdiction", element.getJurisdiction(), -1);
14915    }
14916    if (element.hasLanguage()) {
14917      composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "language", element.getLanguage(), -1);
14918    }
14919  }
14920
14921  protected void composeMedicinalProductDefinitionCrossReferenceComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionCrossReferenceComponent element, int index) {
14922    if (element == null) 
14923      return;
14924    Complex t;
14925    if (Utilities.noString(parentType))
14926      t = parent;
14927    else {
14928      t = parent.predicate("fhir:"+parentType+'.'+name);
14929    }
14930    composeBackboneElement(t, "crossReference", name, element, index);
14931    if (element.hasProduct()) {
14932      composeType(t, "MedicinalProductDefinitionCrossReferenceComponent", "product", element.getProduct(), -1);
14933    }
14934    if (element.hasType()) {
14935      composeCoding(t, "MedicinalProductDefinitionCrossReferenceComponent", "type", element.getType(), -1);
14936    }
14937  }
14938
14939  protected void composeMedicinalProductDefinitionManufacturingBusinessOperationComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionManufacturingBusinessOperationComponent element, int index) {
14940    if (element == null) 
14941      return;
14942    Complex t;
14943    if (Utilities.noString(parentType))
14944      t = parent;
14945    else {
14946      t = parent.predicate("fhir:"+parentType+'.'+name);
14947    }
14948    composeBackboneElement(t, "manufacturingBusinessOperation", name, element, index);
14949    if (element.hasType()) {
14950      composeType(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "type", element.getType(), -1);
14951    }
14952    if (element.hasEffectiveDate()) {
14953      composePeriod(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "effectiveDate", element.getEffectiveDate(), -1);
14954    }
14955    for (int i = 0; i < element.getManufacturer().size(); i++) {
14956      composeReference(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "manufacturer", element.getManufacturer().get(i), i);
14957    }
14958    if (element.hasAuthorization()) {
14959      composeReference(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "authorization", element.getAuthorization(), -1);
14960    }
14961    if (element.hasConfidentialityIndicator()) {
14962      composeCodeableConcept(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "confidentialityIndicator", element.getConfidentialityIndicator(), -1);
14963    }
14964  }
14965
14966  protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) {
14967    if (element == null) 
14968      return;
14969    Complex t;
14970    if (Utilities.noString(parentType))
14971      t = parent;
14972    else {
14973      t = parent.predicate("fhir:"+parentType+'.'+name);
14974    }
14975    composeCanonicalResource(t, "MessageDefinition", name, element, index);
14976    if (element.hasUrlElement()) {
14977      composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1);
14978    }
14979    for (int i = 0; i < element.getIdentifier().size(); i++) {
14980      composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier().get(i), i);
14981    }
14982    if (element.hasVersionElement()) {
14983      composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1);
14984    }
14985    if (element.hasNameElement()) {
14986      composeString(t, "MessageDefinition", "name", element.getNameElement(), -1);
14987    }
14988    if (element.hasTitleElement()) {
14989      composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1);
14990    }
14991    for (int i = 0; i < element.getReplaces().size(); i++) {
14992      composeCanonical(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i);
14993    }
14994    if (element.hasStatusElement()) {
14995      composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1);
14996    }
14997    if (element.hasExperimentalElement()) {
14998      composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1);
14999    }
15000    if (element.hasDateElement()) {
15001      composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1);
15002    }
15003    if (element.hasPublisherElement()) {
15004      composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1);
15005    }
15006    for (int i = 0; i < element.getContact().size(); i++) {
15007      composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i);
15008    }
15009    if (element.hasDescriptionElement()) {
15010      composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1);
15011    }
15012    for (int i = 0; i < element.getUseContext().size(); i++) {
15013      composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i);
15014    }
15015    for (int i = 0; i < element.getJurisdiction().size(); i++) {
15016      composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
15017    }
15018    if (element.hasPurposeElement()) {
15019      composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1);
15020    }
15021    if (element.hasCopyrightElement()) {
15022      composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1);
15023    }
15024    if (element.hasBaseElement()) {
15025      composeCanonical(t, "MessageDefinition", "base", element.getBaseElement(), -1);
15026    }
15027    for (int i = 0; i < element.getParent().size(); i++) {
15028      composeCanonical(t, "MessageDefinition", "parent", element.getParent().get(i), i);
15029    }
15030    if (element.hasEvent()) {
15031      composeType(t, "MessageDefinition", "event", element.getEvent(), -1);
15032    }
15033    if (element.hasCategoryElement()) {
15034      composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1);
15035    }
15036    for (int i = 0; i < element.getFocus().size(); i++) {
15037      composeMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i);
15038    }
15039    if (element.hasResponseRequiredElement()) {
15040      composeEnum(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1);
15041    }
15042    for (int i = 0; i < element.getAllowedResponse().size(); i++) {
15043      composeMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i);
15044    }
15045    for (int i = 0; i < element.getGraph().size(); i++) {
15046      composeCanonical(t, "MessageDefinition", "graph", element.getGraph().get(i), i);
15047    }
15048  }
15049
15050  protected void composeMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) {
15051    if (element == null) 
15052      return;
15053    Complex t;
15054    if (Utilities.noString(parentType))
15055      t = parent;
15056    else {
15057      t = parent.predicate("fhir:"+parentType+'.'+name);
15058    }
15059    composeBackboneElement(t, "focus", name, element, index);
15060    if (element.hasCodeElement()) {
15061      composeCode(t, "MessageDefinitionFocusComponent", "code", element.getCodeElement(), -1);
15062    }
15063    if (element.hasProfileElement()) {
15064      composeCanonical(t, "MessageDefinitionFocusComponent", "profile", element.getProfileElement(), -1);
15065    }
15066    if (element.hasMinElement()) {
15067      composeUnsignedInt(t, "MessageDefinitionFocusComponent", "min", element.getMinElement(), -1);
15068    }
15069    if (element.hasMaxElement()) {
15070      composeString(t, "MessageDefinitionFocusComponent", "max", element.getMaxElement(), -1);
15071    }
15072  }
15073
15074  protected void composeMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent element, int index) {
15075    if (element == null) 
15076      return;
15077    Complex t;
15078    if (Utilities.noString(parentType))
15079      t = parent;
15080    else {
15081      t = parent.predicate("fhir:"+parentType+'.'+name);
15082    }
15083    composeBackboneElement(t, "allowedResponse", name, element, index);
15084    if (element.hasMessageElement()) {
15085      composeCanonical(t, "MessageDefinitionAllowedResponseComponent", "message", element.getMessageElement(), -1);
15086    }
15087    if (element.hasSituationElement()) {
15088      composeMarkdown(t, "MessageDefinitionAllowedResponseComponent", "situation", element.getSituationElement(), -1);
15089    }
15090  }
15091
15092  protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) {
15093    if (element == null) 
15094      return;
15095    Complex t;
15096    if (Utilities.noString(parentType))
15097      t = parent;
15098    else {
15099      t = parent.predicate("fhir:"+parentType+'.'+name);
15100    }
15101    composeDomainResource(t, "MessageHeader", name, element, index);
15102    if (element.hasEvent()) {
15103      composeType(t, "MessageHeader", "event", element.getEvent(), -1);
15104    }
15105    for (int i = 0; i < element.getDestination().size(); i++) {
15106      composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i);
15107    }
15108    if (element.hasSender()) {
15109      composeReference(t, "MessageHeader", "sender", element.getSender(), -1);
15110    }
15111    if (element.hasEnterer()) {
15112      composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1);
15113    }
15114    if (element.hasAuthor()) {
15115      composeReference(t, "MessageHeader", "author", element.getAuthor(), -1);
15116    }
15117    if (element.hasSource()) {
15118      composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1);
15119    }
15120    if (element.hasResponsible()) {
15121      composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1);
15122    }
15123    if (element.hasReason()) {
15124      composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1);
15125    }
15126    if (element.hasResponse()) {
15127      composeMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1);
15128    }
15129    for (int i = 0; i < element.getFocus().size(); i++) {
15130      composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i);
15131    }
15132    if (element.hasDefinitionElement()) {
15133      composeCanonical(t, "MessageHeader", "definition", element.getDefinitionElement(), -1);
15134    }
15135  }
15136
15137  protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) {
15138    if (element == null) 
15139      return;
15140    Complex t;
15141    if (Utilities.noString(parentType))
15142      t = parent;
15143    else {
15144      t = parent.predicate("fhir:"+parentType+'.'+name);
15145    }
15146    composeBackboneElement(t, "destination", name, element, index);
15147    if (element.hasNameElement()) {
15148      composeString(t, "MessageDestinationComponent", "name", element.getNameElement(), -1);
15149    }
15150    if (element.hasTarget()) {
15151      composeReference(t, "MessageDestinationComponent", "target", element.getTarget(), -1);
15152    }
15153    if (element.hasEndpointElement()) {
15154      composeUrl(t, "MessageDestinationComponent", "endpoint", element.getEndpointElement(), -1);
15155    }
15156    if (element.hasReceiver()) {
15157      composeReference(t, "MessageDestinationComponent", "receiver", element.getReceiver(), -1);
15158    }
15159  }
15160
15161  protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) {
15162    if (element == null) 
15163      return;
15164    Complex t;
15165    if (Utilities.noString(parentType))
15166      t = parent;
15167    else {
15168      t = parent.predicate("fhir:"+parentType+'.'+name);
15169    }
15170    composeBackboneElement(t, "source", name, element, index);
15171    if (element.hasNameElement()) {
15172      composeString(t, "MessageSourceComponent", "name", element.getNameElement(), -1);
15173    }
15174    if (element.hasSoftwareElement()) {
15175      composeString(t, "MessageSourceComponent", "software", element.getSoftwareElement(), -1);
15176    }
15177    if (element.hasVersionElement()) {
15178      composeString(t, "MessageSourceComponent", "version", element.getVersionElement(), -1);
15179    }
15180    if (element.hasContact()) {
15181      composeContactPoint(t, "MessageSourceComponent", "contact", element.getContact(), -1);
15182    }
15183    if (element.hasEndpointElement()) {
15184      composeUrl(t, "MessageSourceComponent", "endpoint", element.getEndpointElement(), -1);
15185    }
15186  }
15187
15188  protected void composeMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) {
15189    if (element == null) 
15190      return;
15191    Complex t;
15192    if (Utilities.noString(parentType))
15193      t = parent;
15194    else {
15195      t = parent.predicate("fhir:"+parentType+'.'+name);
15196    }
15197    composeBackboneElement(t, "response", name, element, index);
15198    if (element.hasIdentifierElement()) {
15199      composeId(t, "MessageHeaderResponseComponent", "identifier", element.getIdentifierElement(), -1);
15200    }
15201    if (element.hasCodeElement()) {
15202      composeEnum(t, "MessageHeaderResponseComponent", "code", element.getCodeElement(), -1);
15203    }
15204    if (element.hasDetails()) {
15205      composeReference(t, "MessageHeaderResponseComponent", "details", element.getDetails(), -1);
15206    }
15207  }
15208
15209  protected void composeMolecularSequence(Complex parent, String parentType, String name, MolecularSequence element, int index) {
15210    if (element == null) 
15211      return;
15212    Complex t;
15213    if (Utilities.noString(parentType))
15214      t = parent;
15215    else {
15216      t = parent.predicate("fhir:"+parentType+'.'+name);
15217    }
15218    composeDomainResource(t, "MolecularSequence", name, element, index);
15219    for (int i = 0; i < element.getIdentifier().size(); i++) {
15220      composeIdentifier(t, "MolecularSequence", "identifier", element.getIdentifier().get(i), i);
15221    }
15222    if (element.hasTypeElement()) {
15223      composeEnum(t, "MolecularSequence", "type", element.getTypeElement(), -1);
15224    }
15225    if (element.hasCoordinateSystemElement()) {
15226      composeInteger(t, "MolecularSequence", "coordinateSystem", element.getCoordinateSystemElement(), -1);
15227    }
15228    if (element.hasPatient()) {
15229      composeReference(t, "MolecularSequence", "patient", element.getPatient(), -1);
15230    }
15231    if (element.hasSpecimen()) {
15232      composeReference(t, "MolecularSequence", "specimen", element.getSpecimen(), -1);
15233    }
15234    if (element.hasDevice()) {
15235      composeReference(t, "MolecularSequence", "device", element.getDevice(), -1);
15236    }
15237    if (element.hasPerformer()) {
15238      composeReference(t, "MolecularSequence", "performer", element.getPerformer(), -1);
15239    }
15240    if (element.hasQuantity()) {
15241      composeQuantity(t, "MolecularSequence", "quantity", element.getQuantity(), -1);
15242    }
15243    if (element.hasReferenceSeq()) {
15244      composeMolecularSequenceReferenceSeqComponent(t, "MolecularSequence", "referenceSeq", element.getReferenceSeq(), -1);
15245    }
15246    for (int i = 0; i < element.getVariant().size(); i++) {
15247      composeMolecularSequenceVariantComponent(t, "MolecularSequence", "variant", element.getVariant().get(i), i);
15248    }
15249    if (element.hasObservedSeqElement()) {
15250      composeString(t, "MolecularSequence", "observedSeq", element.getObservedSeqElement(), -1);
15251    }
15252    for (int i = 0; i < element.getQuality().size(); i++) {
15253      composeMolecularSequenceQualityComponent(t, "MolecularSequence", "quality", element.getQuality().get(i), i);
15254    }
15255    if (element.hasReadCoverageElement()) {
15256      composeInteger(t, "MolecularSequence", "readCoverage", element.getReadCoverageElement(), -1);
15257    }
15258    for (int i = 0; i < element.getRepository().size(); i++) {
15259      composeMolecularSequenceRepositoryComponent(t, "MolecularSequence", "repository", element.getRepository().get(i), i);
15260    }
15261    for (int i = 0; i < element.getPointer().size(); i++) {
15262      composeReference(t, "MolecularSequence", "pointer", element.getPointer().get(i), i);
15263    }
15264    for (int i = 0; i < element.getStructureVariant().size(); i++) {
15265      composeMolecularSequenceStructureVariantComponent(t, "MolecularSequence", "structureVariant", element.getStructureVariant().get(i), i);
15266    }
15267  }
15268
15269  protected void composeMolecularSequenceReferenceSeqComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceReferenceSeqComponent element, int index) {
15270    if (element == null) 
15271      return;
15272    Complex t;
15273    if (Utilities.noString(parentType))
15274      t = parent;
15275    else {
15276      t = parent.predicate("fhir:"+parentType+'.'+name);
15277    }
15278    composeBackboneElement(t, "referenceSeq", name, element, index);
15279    if (element.hasChromosome()) {
15280      composeCodeableConcept(t, "MolecularSequenceReferenceSeqComponent", "chromosome", element.getChromosome(), -1);
15281    }
15282    if (element.hasGenomeBuildElement()) {
15283      composeString(t, "MolecularSequenceReferenceSeqComponent", "genomeBuild", element.getGenomeBuildElement(), -1);
15284    }
15285    if (element.hasOrientationElement()) {
15286      composeEnum(t, "MolecularSequenceReferenceSeqComponent", "orientation", element.getOrientationElement(), -1);
15287    }
15288    if (element.hasReferenceSeqId()) {
15289      composeCodeableConcept(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqId", element.getReferenceSeqId(), -1);
15290    }
15291    if (element.hasReferenceSeqPointer()) {
15292      composeReference(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqPointer", element.getReferenceSeqPointer(), -1);
15293    }
15294    if (element.hasReferenceSeqStringElement()) {
15295      composeString(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqString", element.getReferenceSeqStringElement(), -1);
15296    }
15297    if (element.hasStrandElement()) {
15298      composeEnum(t, "MolecularSequenceReferenceSeqComponent", "strand", element.getStrandElement(), -1);
15299    }
15300    if (element.hasWindowStartElement()) {
15301      composeInteger(t, "MolecularSequenceReferenceSeqComponent", "windowStart", element.getWindowStartElement(), -1);
15302    }
15303    if (element.hasWindowEndElement()) {
15304      composeInteger(t, "MolecularSequenceReferenceSeqComponent", "windowEnd", element.getWindowEndElement(), -1);
15305    }
15306  }
15307
15308  protected void composeMolecularSequenceVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceVariantComponent 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, "variant", name, element, index);
15318    if (element.hasStartElement()) {
15319      composeInteger(t, "MolecularSequenceVariantComponent", "start", element.getStartElement(), -1);
15320    }
15321    if (element.hasEndElement()) {
15322      composeInteger(t, "MolecularSequenceVariantComponent", "end", element.getEndElement(), -1);
15323    }
15324    if (element.hasObservedAlleleElement()) {
15325      composeString(t, "MolecularSequenceVariantComponent", "observedAllele", element.getObservedAlleleElement(), -1);
15326    }
15327    if (element.hasReferenceAlleleElement()) {
15328      composeString(t, "MolecularSequenceVariantComponent", "referenceAllele", element.getReferenceAlleleElement(), -1);
15329    }
15330    if (element.hasCigarElement()) {
15331      composeString(t, "MolecularSequenceVariantComponent", "cigar", element.getCigarElement(), -1);
15332    }
15333    if (element.hasVariantPointer()) {
15334      composeReference(t, "MolecularSequenceVariantComponent", "variantPointer", element.getVariantPointer(), -1);
15335    }
15336  }
15337
15338  protected void composeMolecularSequenceQualityComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityComponent element, int index) {
15339    if (element == null) 
15340      return;
15341    Complex t;
15342    if (Utilities.noString(parentType))
15343      t = parent;
15344    else {
15345      t = parent.predicate("fhir:"+parentType+'.'+name);
15346    }
15347    composeBackboneElement(t, "quality", name, element, index);
15348    if (element.hasTypeElement()) {
15349      composeEnum(t, "MolecularSequenceQualityComponent", "type", element.getTypeElement(), -1);
15350    }
15351    if (element.hasStandardSequence()) {
15352      composeCodeableConcept(t, "MolecularSequenceQualityComponent", "standardSequence", element.getStandardSequence(), -1);
15353    }
15354    if (element.hasStartElement()) {
15355      composeInteger(t, "MolecularSequenceQualityComponent", "start", element.getStartElement(), -1);
15356    }
15357    if (element.hasEndElement()) {
15358      composeInteger(t, "MolecularSequenceQualityComponent", "end", element.getEndElement(), -1);
15359    }
15360    if (element.hasScore()) {
15361      composeQuantity(t, "MolecularSequenceQualityComponent", "score", element.getScore(), -1);
15362    }
15363    if (element.hasMethod()) {
15364      composeCodeableConcept(t, "MolecularSequenceQualityComponent", "method", element.getMethod(), -1);
15365    }
15366    if (element.hasTruthTPElement()) {
15367      composeDecimal(t, "MolecularSequenceQualityComponent", "truthTP", element.getTruthTPElement(), -1);
15368    }
15369    if (element.hasQueryTPElement()) {
15370      composeDecimal(t, "MolecularSequenceQualityComponent", "queryTP", element.getQueryTPElement(), -1);
15371    }
15372    if (element.hasTruthFNElement()) {
15373      composeDecimal(t, "MolecularSequenceQualityComponent", "truthFN", element.getTruthFNElement(), -1);
15374    }
15375    if (element.hasQueryFPElement()) {
15376      composeDecimal(t, "MolecularSequenceQualityComponent", "queryFP", element.getQueryFPElement(), -1);
15377    }
15378    if (element.hasGtFPElement()) {
15379      composeDecimal(t, "MolecularSequenceQualityComponent", "gtFP", element.getGtFPElement(), -1);
15380    }
15381    if (element.hasPrecisionElement()) {
15382      composeDecimal(t, "MolecularSequenceQualityComponent", "precision", element.getPrecisionElement(), -1);
15383    }
15384    if (element.hasRecallElement()) {
15385      composeDecimal(t, "MolecularSequenceQualityComponent", "recall", element.getRecallElement(), -1);
15386    }
15387    if (element.hasFScoreElement()) {
15388      composeDecimal(t, "MolecularSequenceQualityComponent", "fScore", element.getFScoreElement(), -1);
15389    }
15390    if (element.hasRoc()) {
15391      composeMolecularSequenceQualityRocComponent(t, "MolecularSequenceQualityComponent", "roc", element.getRoc(), -1);
15392    }
15393  }
15394
15395  protected void composeMolecularSequenceQualityRocComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityRocComponent 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, "roc", name, element, index);
15405    for (int i = 0; i < element.getScore().size(); i++) {
15406      composeInteger(t, "MolecularSequenceQualityRocComponent", "score", element.getScore().get(i), i);
15407    }
15408    for (int i = 0; i < element.getNumTP().size(); i++) {
15409      composeInteger(t, "MolecularSequenceQualityRocComponent", "numTP", element.getNumTP().get(i), i);
15410    }
15411    for (int i = 0; i < element.getNumFP().size(); i++) {
15412      composeInteger(t, "MolecularSequenceQualityRocComponent", "numFP", element.getNumFP().get(i), i);
15413    }
15414    for (int i = 0; i < element.getNumFN().size(); i++) {
15415      composeInteger(t, "MolecularSequenceQualityRocComponent", "numFN", element.getNumFN().get(i), i);
15416    }
15417    for (int i = 0; i < element.getPrecision().size(); i++) {
15418      composeDecimal(t, "MolecularSequenceQualityRocComponent", "precision", element.getPrecision().get(i), i);
15419    }
15420    for (int i = 0; i < element.getSensitivity().size(); i++) {
15421      composeDecimal(t, "MolecularSequenceQualityRocComponent", "sensitivity", element.getSensitivity().get(i), i);
15422    }
15423    for (int i = 0; i < element.getFMeasure().size(); i++) {
15424      composeDecimal(t, "MolecularSequenceQualityRocComponent", "fMeasure", element.getFMeasure().get(i), i);
15425    }
15426  }
15427
15428  protected void composeMolecularSequenceRepositoryComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceRepositoryComponent element, int index) {
15429    if (element == null) 
15430      return;
15431    Complex t;
15432    if (Utilities.noString(parentType))
15433      t = parent;
15434    else {
15435      t = parent.predicate("fhir:"+parentType+'.'+name);
15436    }
15437    composeBackboneElement(t, "repository", name, element, index);
15438    if (element.hasTypeElement()) {
15439      composeEnum(t, "MolecularSequenceRepositoryComponent", "type", element.getTypeElement(), -1);
15440    }
15441    if (element.hasUrlElement()) {
15442      composeUri(t, "MolecularSequenceRepositoryComponent", "url", element.getUrlElement(), -1);
15443    }
15444    if (element.hasNameElement()) {
15445      composeString(t, "MolecularSequenceRepositoryComponent", "name", element.getNameElement(), -1);
15446    }
15447    if (element.hasDatasetIdElement()) {
15448      composeString(t, "MolecularSequenceRepositoryComponent", "datasetId", element.getDatasetIdElement(), -1);
15449    }
15450    if (element.hasVariantsetIdElement()) {
15451      composeString(t, "MolecularSequenceRepositoryComponent", "variantsetId", element.getVariantsetIdElement(), -1);
15452    }
15453    if (element.hasReadsetIdElement()) {
15454      composeString(t, "MolecularSequenceRepositoryComponent", "readsetId", element.getReadsetIdElement(), -1);
15455    }
15456  }
15457
15458  protected void composeMolecularSequenceStructureVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantComponent element, int index) {
15459    if (element == null) 
15460      return;
15461    Complex t;
15462    if (Utilities.noString(parentType))
15463      t = parent;
15464    else {
15465      t = parent.predicate("fhir:"+parentType+'.'+name);
15466    }
15467    composeBackboneElement(t, "structureVariant", name, element, index);
15468    if (element.hasVariantType()) {
15469      composeCodeableConcept(t, "MolecularSequenceStructureVariantComponent", "variantType", element.getVariantType(), -1);
15470    }
15471    if (element.hasExactElement()) {
15472      composeBoolean(t, "MolecularSequenceStructureVariantComponent", "exact", element.getExactElement(), -1);
15473    }
15474    if (element.hasLengthElement()) {
15475      composeInteger(t, "MolecularSequenceStructureVariantComponent", "length", element.getLengthElement(), -1);
15476    }
15477    if (element.hasOuter()) {
15478      composeMolecularSequenceStructureVariantOuterComponent(t, "MolecularSequenceStructureVariantComponent", "outer", element.getOuter(), -1);
15479    }
15480    if (element.hasInner()) {
15481      composeMolecularSequenceStructureVariantInnerComponent(t, "MolecularSequenceStructureVariantComponent", "inner", element.getInner(), -1);
15482    }
15483  }
15484
15485  protected void composeMolecularSequenceStructureVariantOuterComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantOuterComponent element, int index) {
15486    if (element == null) 
15487      return;
15488    Complex t;
15489    if (Utilities.noString(parentType))
15490      t = parent;
15491    else {
15492      t = parent.predicate("fhir:"+parentType+'.'+name);
15493    }
15494    composeBackboneElement(t, "outer", name, element, index);
15495    if (element.hasStartElement()) {
15496      composeInteger(t, "MolecularSequenceStructureVariantOuterComponent", "start", element.getStartElement(), -1);
15497    }
15498    if (element.hasEndElement()) {
15499      composeInteger(t, "MolecularSequenceStructureVariantOuterComponent", "end", element.getEndElement(), -1);
15500    }
15501  }
15502
15503  protected void composeMolecularSequenceStructureVariantInnerComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantInnerComponent element, int index) {
15504    if (element == null) 
15505      return;
15506    Complex t;
15507    if (Utilities.noString(parentType))
15508      t = parent;
15509    else {
15510      t = parent.predicate("fhir:"+parentType+'.'+name);
15511    }
15512    composeBackboneElement(t, "inner", name, element, index);
15513    if (element.hasStartElement()) {
15514      composeInteger(t, "MolecularSequenceStructureVariantInnerComponent", "start", element.getStartElement(), -1);
15515    }
15516    if (element.hasEndElement()) {
15517      composeInteger(t, "MolecularSequenceStructureVariantInnerComponent", "end", element.getEndElement(), -1);
15518    }
15519  }
15520
15521  protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) {
15522    if (element == null) 
15523      return;
15524    Complex t;
15525    if (Utilities.noString(parentType))
15526      t = parent;
15527    else {
15528      t = parent.predicate("fhir:"+parentType+'.'+name);
15529    }
15530    composeCanonicalResource(t, "NamingSystem", name, element, index);
15531    if (element.hasUrlElement()) {
15532      composeUri(t, "NamingSystem", "url", element.getUrlElement(), -1);
15533    }
15534    if (element.hasVersionElement()) {
15535      composeString(t, "NamingSystem", "version", element.getVersionElement(), -1);
15536    }
15537    if (element.hasNameElement()) {
15538      composeString(t, "NamingSystem", "name", element.getNameElement(), -1);
15539    }
15540    if (element.hasStatusElement()) {
15541      composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1);
15542    }
15543    if (element.hasKindElement()) {
15544      composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1);
15545    }
15546    if (element.hasDateElement()) {
15547      composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1);
15548    }
15549    if (element.hasPublisherElement()) {
15550      composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1);
15551    }
15552    for (int i = 0; i < element.getContact().size(); i++) {
15553      composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i);
15554    }
15555    if (element.hasResponsibleElement()) {
15556      composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1);
15557    }
15558    if (element.hasType()) {
15559      composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1);
15560    }
15561    if (element.hasDescriptionElement()) {
15562      composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1);
15563    }
15564    for (int i = 0; i < element.getUseContext().size(); i++) {
15565      composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i);
15566    }
15567    for (int i = 0; i < element.getJurisdiction().size(); i++) {
15568      composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i);
15569    }
15570    if (element.hasUsageElement()) {
15571      composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1);
15572    }
15573    for (int i = 0; i < element.getUniqueId().size(); i++) {
15574      composeNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i);
15575    }
15576  }
15577
15578  protected void composeNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) {
15579    if (element == null) 
15580      return;
15581    Complex t;
15582    if (Utilities.noString(parentType))
15583      t = parent;
15584    else {
15585      t = parent.predicate("fhir:"+parentType+'.'+name);
15586    }
15587    composeBackboneElement(t, "uniqueId", name, element, index);
15588    if (element.hasTypeElement()) {
15589      composeEnum(t, "NamingSystemUniqueIdComponent", "type", element.getTypeElement(), -1);
15590    }
15591    if (element.hasValueElement()) {
15592      composeString(t, "NamingSystemUniqueIdComponent", "value", element.getValueElement(), -1);
15593    }
15594    if (element.hasPreferredElement()) {
15595      composeBoolean(t, "NamingSystemUniqueIdComponent", "preferred", element.getPreferredElement(), -1);
15596    }
15597    if (element.hasCommentElement()) {
15598      composeString(t, "NamingSystemUniqueIdComponent", "comment", element.getCommentElement(), -1);
15599    }
15600    if (element.hasPeriod()) {
15601      composePeriod(t, "NamingSystemUniqueIdComponent", "period", element.getPeriod(), -1);
15602    }
15603  }
15604
15605  protected void composeNutritionIntake(Complex parent, String parentType, String name, NutritionIntake element, int index) {
15606    if (element == null) 
15607      return;
15608    Complex t;
15609    if (Utilities.noString(parentType))
15610      t = parent;
15611    else {
15612      t = parent.predicate("fhir:"+parentType+'.'+name);
15613    }
15614    composeDomainResource(t, "NutritionIntake", name, element, index);
15615    for (int i = 0; i < element.getIdentifier().size(); i++) {
15616      composeIdentifier(t, "NutritionIntake", "identifier", element.getIdentifier().get(i), i);
15617    }
15618    for (int i = 0; i < element.getBasedOn().size(); i++) {
15619      composeReference(t, "NutritionIntake", "basedOn", element.getBasedOn().get(i), i);
15620    }
15621    for (int i = 0; i < element.getPartOf().size(); i++) {
15622      composeReference(t, "NutritionIntake", "partOf", element.getPartOf().get(i), i);
15623    }
15624    if (element.hasStatusElement()) {
15625      composeEnum(t, "NutritionIntake", "status", element.getStatusElement(), -1);
15626    }
15627    for (int i = 0; i < element.getStatusReason().size(); i++) {
15628      composeCodeableConcept(t, "NutritionIntake", "statusReason", element.getStatusReason().get(i), i);
15629    }
15630    for (int i = 0; i < element.getCategory().size(); i++) {
15631      composeCodeableConcept(t, "NutritionIntake", "category", element.getCategory().get(i), i);
15632    }
15633    for (int i = 0; i < element.getConsumedItem().size(); i++) {
15634      composeNutritionIntakeConsumedItemComponent(t, "NutritionIntake", "consumedItem", element.getConsumedItem().get(i), i);
15635    }
15636    for (int i = 0; i < element.getIngredientLabel().size(); i++) {
15637      composeNutritionIntakeIngredientLabelComponent(t, "NutritionIntake", "ingredientLabel", element.getIngredientLabel().get(i), i);
15638    }
15639    if (element.hasSubject()) {
15640      composeReference(t, "NutritionIntake", "subject", element.getSubject(), -1);
15641    }
15642    if (element.hasEncounter()) {
15643      composeReference(t, "NutritionIntake", "encounter", element.getEncounter(), -1);
15644    }
15645    if (element.hasEffective()) {
15646      composeType(t, "NutritionIntake", "effective", element.getEffective(), -1);
15647    }
15648    if (element.hasDateAssertedElement()) {
15649      composeDateTime(t, "NutritionIntake", "dateAsserted", element.getDateAssertedElement(), -1);
15650    }
15651    if (element.hasInformationSource()) {
15652      composeReference(t, "NutritionIntake", "informationSource", element.getInformationSource(), -1);
15653    }
15654    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
15655      composeReference(t, "NutritionIntake", "derivedFrom", element.getDerivedFrom().get(i), i);
15656    }
15657    for (int i = 0; i < element.getReasonCode().size(); i++) {
15658      composeCodeableReference(t, "NutritionIntake", "reasonCode", element.getReasonCode().get(i), i);
15659    }
15660    for (int i = 0; i < element.getNote().size(); i++) {
15661      composeAnnotation(t, "NutritionIntake", "note", element.getNote().get(i), i);
15662    }
15663  }
15664
15665  protected void composeNutritionIntakeConsumedItemComponent(Complex parent, String parentType, String name, NutritionIntake.NutritionIntakeConsumedItemComponent element, int index) {
15666    if (element == null) 
15667      return;
15668    Complex t;
15669    if (Utilities.noString(parentType))
15670      t = parent;
15671    else {
15672      t = parent.predicate("fhir:"+parentType+'.'+name);
15673    }
15674    composeBackboneElement(t, "consumedItem", name, element, index);
15675    if (element.hasType()) {
15676      composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "type", element.getType(), -1);
15677    }
15678    if (element.hasNutritionProduct()) {
15679      composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "nutritionProduct", element.getNutritionProduct(), -1);
15680    }
15681    if (element.hasSchedule()) {
15682      composeTiming(t, "NutritionIntakeConsumedItemComponent", "schedule", element.getSchedule(), -1);
15683    }
15684    if (element.hasAmount()) {
15685      composeQuantity(t, "NutritionIntakeConsumedItemComponent", "amount", element.getAmount(), -1);
15686    }
15687    if (element.hasRate()) {
15688      composeQuantity(t, "NutritionIntakeConsumedItemComponent", "rate", element.getRate(), -1);
15689    }
15690    if (element.hasNotConsumedElement()) {
15691      composeBoolean(t, "NutritionIntakeConsumedItemComponent", "notConsumed", element.getNotConsumedElement(), -1);
15692    }
15693    if (element.hasNotConsumedReason()) {
15694      composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "notConsumedReason", element.getNotConsumedReason(), -1);
15695    }
15696  }
15697
15698  protected void composeNutritionIntakeIngredientLabelComponent(Complex parent, String parentType, String name, NutritionIntake.NutritionIntakeIngredientLabelComponent element, int index) {
15699    if (element == null) 
15700      return;
15701    Complex t;
15702    if (Utilities.noString(parentType))
15703      t = parent;
15704    else {
15705      t = parent.predicate("fhir:"+parentType+'.'+name);
15706    }
15707    composeBackboneElement(t, "ingredientLabel", name, element, index);
15708    if (element.hasNutrient()) {
15709      composeCodeableConcept(t, "NutritionIntakeIngredientLabelComponent", "nutrient", element.getNutrient(), -1);
15710    }
15711    if (element.hasAmount()) {
15712      composeQuantity(t, "NutritionIntakeIngredientLabelComponent", "amount", element.getAmount(), -1);
15713    }
15714  }
15715
15716  protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder 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    composeDomainResource(t, "NutritionOrder", name, element, index);
15726    for (int i = 0; i < element.getIdentifier().size(); i++) {
15727      composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i);
15728    }
15729    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
15730      composeCanonical(t, "NutritionOrder", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
15731    }
15732    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
15733      composeUri(t, "NutritionOrder", "instantiatesUri", element.getInstantiatesUri().get(i), i);
15734    }
15735    for (int i = 0; i < element.getInstantiates().size(); i++) {
15736      composeUri(t, "NutritionOrder", "instantiates", element.getInstantiates().get(i), i);
15737    }
15738    if (element.hasStatusElement()) {
15739      composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1);
15740    }
15741    if (element.hasIntentElement()) {
15742      composeEnum(t, "NutritionOrder", "intent", element.getIntentElement(), -1);
15743    }
15744    if (element.hasPatient()) {
15745      composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1);
15746    }
15747    if (element.hasEncounter()) {
15748      composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1);
15749    }
15750    if (element.hasDateTimeElement()) {
15751      composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1);
15752    }
15753    if (element.hasOrderer()) {
15754      composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1);
15755    }
15756    for (int i = 0; i < element.getAllergyIntolerance().size(); i++) {
15757      composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i);
15758    }
15759    for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) {
15760      composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i);
15761    }
15762    for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) {
15763      composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i);
15764    }
15765    if (element.hasOralDiet()) {
15766      composeNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1);
15767    }
15768    for (int i = 0; i < element.getSupplement().size(); i++) {
15769      composeNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i);
15770    }
15771    if (element.hasEnteralFormula()) {
15772      composeNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1);
15773    }
15774    for (int i = 0; i < element.getNote().size(); i++) {
15775      composeAnnotation(t, "NutritionOrder", "note", element.getNote().get(i), i);
15776    }
15777  }
15778
15779  protected void composeNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent 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    composeBackboneElement(t, "oralDiet", name, element, index);
15789    for (int i = 0; i < element.getType().size(); i++) {
15790      composeCodeableConcept(t, "NutritionOrderOralDietComponent", "type", element.getType().get(i), i);
15791    }
15792    for (int i = 0; i < element.getSchedule().size(); i++) {
15793      composeTiming(t, "NutritionOrderOralDietComponent", "schedule", element.getSchedule().get(i), i);
15794    }
15795    for (int i = 0; i < element.getNutrient().size(); i++) {
15796      composeNutritionOrderOralDietNutrientComponent(t, "NutritionOrderOralDietComponent", "nutrient", element.getNutrient().get(i), i);
15797    }
15798    for (int i = 0; i < element.getTexture().size(); i++) {
15799      composeNutritionOrderOralDietTextureComponent(t, "NutritionOrderOralDietComponent", "texture", element.getTexture().get(i), i);
15800    }
15801    for (int i = 0; i < element.getFluidConsistencyType().size(); i++) {
15802      composeCodeableConcept(t, "NutritionOrderOralDietComponent", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i);
15803    }
15804    if (element.hasInstructionElement()) {
15805      composeString(t, "NutritionOrderOralDietComponent", "instruction", element.getInstructionElement(), -1);
15806    }
15807  }
15808
15809  protected void composeNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) {
15810    if (element == null) 
15811      return;
15812    Complex t;
15813    if (Utilities.noString(parentType))
15814      t = parent;
15815    else {
15816      t = parent.predicate("fhir:"+parentType+'.'+name);
15817    }
15818    composeBackboneElement(t, "nutrient", name, element, index);
15819    if (element.hasModifier()) {
15820      composeCodeableConcept(t, "NutritionOrderOralDietNutrientComponent", "modifier", element.getModifier(), -1);
15821    }
15822    if (element.hasAmount()) {
15823      composeQuantity(t, "NutritionOrderOralDietNutrientComponent", "amount", element.getAmount(), -1);
15824    }
15825  }
15826
15827  protected void composeNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) {
15828    if (element == null) 
15829      return;
15830    Complex t;
15831    if (Utilities.noString(parentType))
15832      t = parent;
15833    else {
15834      t = parent.predicate("fhir:"+parentType+'.'+name);
15835    }
15836    composeBackboneElement(t, "texture", name, element, index);
15837    if (element.hasModifier()) {
15838      composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "modifier", element.getModifier(), -1);
15839    }
15840    if (element.hasFoodType()) {
15841      composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "foodType", element.getFoodType(), -1);
15842    }
15843  }
15844
15845  protected void composeNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) {
15846    if (element == null) 
15847      return;
15848    Complex t;
15849    if (Utilities.noString(parentType))
15850      t = parent;
15851    else {
15852      t = parent.predicate("fhir:"+parentType+'.'+name);
15853    }
15854    composeBackboneElement(t, "supplement", name, element, index);
15855    if (element.hasType()) {
15856      composeCodeableConcept(t, "NutritionOrderSupplementComponent", "type", element.getType(), -1);
15857    }
15858    if (element.hasProductNameElement()) {
15859      composeString(t, "NutritionOrderSupplementComponent", "productName", element.getProductNameElement(), -1);
15860    }
15861    for (int i = 0; i < element.getSchedule().size(); i++) {
15862      composeTiming(t, "NutritionOrderSupplementComponent", "schedule", element.getSchedule().get(i), i);
15863    }
15864    if (element.hasQuantity()) {
15865      composeQuantity(t, "NutritionOrderSupplementComponent", "quantity", element.getQuantity(), -1);
15866    }
15867    if (element.hasInstructionElement()) {
15868      composeString(t, "NutritionOrderSupplementComponent", "instruction", element.getInstructionElement(), -1);
15869    }
15870  }
15871
15872  protected void composeNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent element, int index) {
15873    if (element == null) 
15874      return;
15875    Complex t;
15876    if (Utilities.noString(parentType))
15877      t = parent;
15878    else {
15879      t = parent.predicate("fhir:"+parentType+'.'+name);
15880    }
15881    composeBackboneElement(t, "enteralFormula", name, element, index);
15882    if (element.hasBaseFormulaType()) {
15883      composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaType", element.getBaseFormulaType(), -1);
15884    }
15885    if (element.hasBaseFormulaProductNameElement()) {
15886      composeString(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1);
15887    }
15888    if (element.hasAdditiveType()) {
15889      composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "additiveType", element.getAdditiveType(), -1);
15890    }
15891    if (element.hasAdditiveProductNameElement()) {
15892      composeString(t, "NutritionOrderEnteralFormulaComponent", "additiveProductName", element.getAdditiveProductNameElement(), -1);
15893    }
15894    if (element.hasCaloricDensity()) {
15895      composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "caloricDensity", element.getCaloricDensity(), -1);
15896    }
15897    if (element.hasRouteofAdministration()) {
15898      composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "routeofAdministration", element.getRouteofAdministration(), -1);
15899    }
15900    for (int i = 0; i < element.getAdministration().size(); i++) {
15901      composeNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrderEnteralFormulaComponent", "administration", element.getAdministration().get(i), i);
15902    }
15903    if (element.hasMaxVolumeToDeliver()) {
15904      composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1);
15905    }
15906    if (element.hasAdministrationInstructionElement()) {
15907      composeString(t, "NutritionOrderEnteralFormulaComponent", "administrationInstruction", element.getAdministrationInstructionElement(), -1);
15908    }
15909  }
15910
15911  protected void composeNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element, int index) {
15912    if (element == null) 
15913      return;
15914    Complex t;
15915    if (Utilities.noString(parentType))
15916      t = parent;
15917    else {
15918      t = parent.predicate("fhir:"+parentType+'.'+name);
15919    }
15920    composeBackboneElement(t, "administration", name, element, index);
15921    if (element.hasSchedule()) {
15922      composeTiming(t, "NutritionOrderEnteralFormulaAdministrationComponent", "schedule", element.getSchedule(), -1);
15923    }
15924    if (element.hasQuantity()) {
15925      composeQuantity(t, "NutritionOrderEnteralFormulaAdministrationComponent", "quantity", element.getQuantity(), -1);
15926    }
15927    if (element.hasRate()) {
15928      composeType(t, "NutritionOrderEnteralFormulaAdministrationComponent", "rate", element.getRate(), -1);
15929    }
15930  }
15931
15932  protected void composeObservation(Complex parent, String parentType, String name, Observation element, int index) {
15933    if (element == null) 
15934      return;
15935    Complex t;
15936    if (Utilities.noString(parentType))
15937      t = parent;
15938    else {
15939      t = parent.predicate("fhir:"+parentType+'.'+name);
15940    }
15941    composeDomainResource(t, "Observation", name, element, index);
15942    for (int i = 0; i < element.getIdentifier().size(); i++) {
15943      composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i);
15944    }
15945    for (int i = 0; i < element.getBasedOn().size(); i++) {
15946      composeReference(t, "Observation", "basedOn", element.getBasedOn().get(i), i);
15947    }
15948    for (int i = 0; i < element.getPartOf().size(); i++) {
15949      composeReference(t, "Observation", "partOf", element.getPartOf().get(i), i);
15950    }
15951    if (element.hasStatusElement()) {
15952      composeEnum(t, "Observation", "status", element.getStatusElement(), -1);
15953    }
15954    for (int i = 0; i < element.getCategory().size(); i++) {
15955      composeCodeableConcept(t, "Observation", "category", element.getCategory().get(i), i);
15956    }
15957    if (element.hasCode()) {
15958      composeCodeableConcept(t, "Observation", "code", element.getCode(), -1);
15959    }
15960    if (element.hasSubject()) {
15961      composeReference(t, "Observation", "subject", element.getSubject(), -1);
15962    }
15963    for (int i = 0; i < element.getFocus().size(); i++) {
15964      composeReference(t, "Observation", "focus", element.getFocus().get(i), i);
15965    }
15966    if (element.hasEncounter()) {
15967      composeReference(t, "Observation", "encounter", element.getEncounter(), -1);
15968    }
15969    if (element.hasEffective()) {
15970      composeType(t, "Observation", "effective", element.getEffective(), -1);
15971    }
15972    if (element.hasIssuedElement()) {
15973      composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1);
15974    }
15975    for (int i = 0; i < element.getPerformer().size(); i++) {
15976      composeReference(t, "Observation", "performer", element.getPerformer().get(i), i);
15977    }
15978    if (element.hasValue()) {
15979      composeType(t, "Observation", "value", element.getValue(), -1);
15980    }
15981    if (element.hasDataAbsentReason()) {
15982      composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1);
15983    }
15984    for (int i = 0; i < element.getInterpretation().size(); i++) {
15985      composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation().get(i), i);
15986    }
15987    for (int i = 0; i < element.getNote().size(); i++) {
15988      composeAnnotation(t, "Observation", "note", element.getNote().get(i), i);
15989    }
15990    if (element.hasBodySite()) {
15991      composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1);
15992    }
15993    if (element.hasMethod()) {
15994      composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1);
15995    }
15996    if (element.hasSpecimen()) {
15997      composeReference(t, "Observation", "specimen", element.getSpecimen(), -1);
15998    }
15999    if (element.hasDevice()) {
16000      composeReference(t, "Observation", "device", element.getDevice(), -1);
16001    }
16002    for (int i = 0; i < element.getReferenceRange().size(); i++) {
16003      composeObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i);
16004    }
16005    for (int i = 0; i < element.getHasMember().size(); i++) {
16006      composeReference(t, "Observation", "hasMember", element.getHasMember().get(i), i);
16007    }
16008    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
16009      composeReference(t, "Observation", "derivedFrom", element.getDerivedFrom().get(i), i);
16010    }
16011    for (int i = 0; i < element.getComponent().size(); i++) {
16012      composeObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i);
16013    }
16014  }
16015
16016  protected void composeObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent element, int index) {
16017    if (element == null) 
16018      return;
16019    Complex t;
16020    if (Utilities.noString(parentType))
16021      t = parent;
16022    else {
16023      t = parent.predicate("fhir:"+parentType+'.'+name);
16024    }
16025    composeBackboneElement(t, "referenceRange", name, element, index);
16026    if (element.hasLow()) {
16027      composeQuantity(t, "ObservationReferenceRangeComponent", "low", element.getLow(), -1);
16028    }
16029    if (element.hasHigh()) {
16030      composeQuantity(t, "ObservationReferenceRangeComponent", "high", element.getHigh(), -1);
16031    }
16032    if (element.hasType()) {
16033      composeCodeableConcept(t, "ObservationReferenceRangeComponent", "type", element.getType(), -1);
16034    }
16035    for (int i = 0; i < element.getAppliesTo().size(); i++) {
16036      composeCodeableConcept(t, "ObservationReferenceRangeComponent", "appliesTo", element.getAppliesTo().get(i), i);
16037    }
16038    if (element.hasAge()) {
16039      composeRange(t, "ObservationReferenceRangeComponent", "age", element.getAge(), -1);
16040    }
16041    if (element.hasTextElement()) {
16042      composeString(t, "ObservationReferenceRangeComponent", "text", element.getTextElement(), -1);
16043    }
16044  }
16045
16046  protected void composeObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent element, int index) {
16047    if (element == null) 
16048      return;
16049    Complex t;
16050    if (Utilities.noString(parentType))
16051      t = parent;
16052    else {
16053      t = parent.predicate("fhir:"+parentType+'.'+name);
16054    }
16055    composeBackboneElement(t, "component", name, element, index);
16056    if (element.hasCode()) {
16057      composeCodeableConcept(t, "ObservationComponentComponent", "code", element.getCode(), -1);
16058    }
16059    if (element.hasValue()) {
16060      composeType(t, "ObservationComponentComponent", "value", element.getValue(), -1);
16061    }
16062    if (element.hasDataAbsentReason()) {
16063      composeCodeableConcept(t, "ObservationComponentComponent", "dataAbsentReason", element.getDataAbsentReason(), -1);
16064    }
16065    for (int i = 0; i < element.getInterpretation().size(); i++) {
16066      composeCodeableConcept(t, "ObservationComponentComponent", "interpretation", element.getInterpretation().get(i), i);
16067    }
16068    for (int i = 0; i < element.getReferenceRange().size(); i++) {
16069      composeObservationReferenceRangeComponent(t, "ObservationComponentComponent", "referenceRange", element.getReferenceRange().get(i), i);
16070    }
16071  }
16072
16073  protected void composeObservationDefinition(Complex parent, String parentType, String name, ObservationDefinition 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, "ObservationDefinition", name, element, index);
16083    if (element.hasUrlElement()) {
16084      composeUri(t, "ObservationDefinition", "url", element.getUrlElement(), -1);
16085    }
16086    if (element.hasIdentifier()) {
16087      composeIdentifier(t, "ObservationDefinition", "identifier", element.getIdentifier(), -1);
16088    }
16089    if (element.hasVersionElement()) {
16090      composeString(t, "ObservationDefinition", "version", element.getVersionElement(), -1);
16091    }
16092    if (element.hasTitleElement()) {
16093      composeString(t, "ObservationDefinition", "title", element.getTitleElement(), -1);
16094    }
16095    for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) {
16096      composeCanonical(t, "ObservationDefinition", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i);
16097    }
16098    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
16099      composeUri(t, "ObservationDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
16100    }
16101    if (element.hasStatusElement()) {
16102      composeEnum(t, "ObservationDefinition", "status", element.getStatusElement(), -1);
16103    }
16104    if (element.hasExperimentalElement()) {
16105      composeBoolean(t, "ObservationDefinition", "experimental", element.getExperimentalElement(), -1);
16106    }
16107    if (element.hasSubject()) {
16108      composeType(t, "ObservationDefinition", "subject", element.getSubject(), -1);
16109    }
16110    if (element.hasDateElement()) {
16111      composeDateTime(t, "ObservationDefinition", "date", element.getDateElement(), -1);
16112    }
16113    if (element.hasPublisher()) {
16114      composeReference(t, "ObservationDefinition", "publisher", element.getPublisher(), -1);
16115    }
16116    for (int i = 0; i < element.getContact().size(); i++) {
16117      composeContactDetail(t, "ObservationDefinition", "contact", element.getContact().get(i), i);
16118    }
16119    if (element.hasDescriptionElement()) {
16120      composeMarkdown(t, "ObservationDefinition", "description", element.getDescriptionElement(), -1);
16121    }
16122    for (int i = 0; i < element.getUseContext().size(); i++) {
16123      composeUsageContext(t, "ObservationDefinition", "useContext", element.getUseContext().get(i), i);
16124    }
16125    for (int i = 0; i < element.getJurisdiction().size(); i++) {
16126      composeCodeableConcept(t, "ObservationDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
16127    }
16128    if (element.hasPurposeElement()) {
16129      composeMarkdown(t, "ObservationDefinition", "purpose", element.getPurposeElement(), -1);
16130    }
16131    if (element.hasCopyrightElement()) {
16132      composeMarkdown(t, "ObservationDefinition", "copyright", element.getCopyrightElement(), -1);
16133    }
16134    if (element.hasApprovalDateElement()) {
16135      composeDate(t, "ObservationDefinition", "approvalDate", element.getApprovalDateElement(), -1);
16136    }
16137    if (element.hasLastReviewDateElement()) {
16138      composeDate(t, "ObservationDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
16139    }
16140    if (element.hasEffectivePeriod()) {
16141      composePeriod(t, "ObservationDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
16142    }
16143    if (element.hasPerformerType()) {
16144      composeCodeableConcept(t, "ObservationDefinition", "performerType", element.getPerformerType(), -1);
16145    }
16146    for (int i = 0; i < element.getCategory().size(); i++) {
16147      composeCodeableConcept(t, "ObservationDefinition", "category", element.getCategory().get(i), i);
16148    }
16149    if (element.hasCode()) {
16150      composeCodeableConcept(t, "ObservationDefinition", "code", element.getCode(), -1);
16151    }
16152    for (int i = 0; i < element.getPermittedDataType().size(); i++) {
16153      composeEnum(t, "ObservationDefinition", "permittedDataType", element.getPermittedDataType().get(i), i);
16154    }
16155    if (element.hasMultipleResultsAllowedElement()) {
16156      composeBoolean(t, "ObservationDefinition", "multipleResultsAllowed", element.getMultipleResultsAllowedElement(), -1);
16157    }
16158    if (element.hasBodySite()) {
16159      composeCodeableConcept(t, "ObservationDefinition", "bodySite", element.getBodySite(), -1);
16160    }
16161    if (element.hasMethod()) {
16162      composeCodeableConcept(t, "ObservationDefinition", "method", element.getMethod(), -1);
16163    }
16164    if (element.hasSpecimen()) {
16165      composeReference(t, "ObservationDefinition", "specimen", element.getSpecimen(), -1);
16166    }
16167    if (element.hasDevice()) {
16168      composeReference(t, "ObservationDefinition", "device", element.getDevice(), -1);
16169    }
16170    if (element.hasPreferredReportNameElement()) {
16171      composeString(t, "ObservationDefinition", "preferredReportName", element.getPreferredReportNameElement(), -1);
16172    }
16173    if (element.hasQuantitativeDetails()) {
16174      composeObservationDefinitionQuantitativeDetailsComponent(t, "ObservationDefinition", "quantitativeDetails", element.getQuantitativeDetails(), -1);
16175    }
16176    for (int i = 0; i < element.getQualifiedInterval().size(); i++) {
16177      composeObservationDefinitionQualifiedIntervalComponent(t, "ObservationDefinition", "qualifiedInterval", element.getQualifiedInterval().get(i), i);
16178    }
16179    if (element.hasValidCodedValueSet()) {
16180      composeReference(t, "ObservationDefinition", "validCodedValueSet", element.getValidCodedValueSet(), -1);
16181    }
16182    if (element.hasNormalCodedValueSet()) {
16183      composeReference(t, "ObservationDefinition", "normalCodedValueSet", element.getNormalCodedValueSet(), -1);
16184    }
16185    if (element.hasAbnormalCodedValueSet()) {
16186      composeReference(t, "ObservationDefinition", "abnormalCodedValueSet", element.getAbnormalCodedValueSet(), -1);
16187    }
16188    if (element.hasCriticalCodedValueSet()) {
16189      composeReference(t, "ObservationDefinition", "criticalCodedValueSet", element.getCriticalCodedValueSet(), -1);
16190    }
16191    for (int i = 0; i < element.getHasMember().size(); i++) {
16192      composeReference(t, "ObservationDefinition", "hasMember", element.getHasMember().get(i), i);
16193    }
16194    for (int i = 0; i < element.getComponent().size(); i++) {
16195      composeObservationDefinitionComponentComponent(t, "ObservationDefinition", "component", element.getComponent().get(i), i);
16196    }
16197  }
16198
16199  protected void composeObservationDefinitionQuantitativeDetailsComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQuantitativeDetailsComponent element, int index) {
16200    if (element == null) 
16201      return;
16202    Complex t;
16203    if (Utilities.noString(parentType))
16204      t = parent;
16205    else {
16206      t = parent.predicate("fhir:"+parentType+'.'+name);
16207    }
16208    composeBackboneElement(t, "quantitativeDetails", name, element, index);
16209    if (element.hasCustomaryUnit()) {
16210      composeCodeableConcept(t, "ObservationDefinitionQuantitativeDetailsComponent", "customaryUnit", element.getCustomaryUnit(), -1);
16211    }
16212    if (element.hasUnit()) {
16213      composeCodeableConcept(t, "ObservationDefinitionQuantitativeDetailsComponent", "unit", element.getUnit(), -1);
16214    }
16215    if (element.hasConversionFactorElement()) {
16216      composeDecimal(t, "ObservationDefinitionQuantitativeDetailsComponent", "conversionFactor", element.getConversionFactorElement(), -1);
16217    }
16218    if (element.hasDecimalPrecisionElement()) {
16219      composeInteger(t, "ObservationDefinitionQuantitativeDetailsComponent", "decimalPrecision", element.getDecimalPrecisionElement(), -1);
16220    }
16221  }
16222
16223  protected void composeObservationDefinitionQualifiedIntervalComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQualifiedIntervalComponent element, int index) {
16224    if (element == null) 
16225      return;
16226    Complex t;
16227    if (Utilities.noString(parentType))
16228      t = parent;
16229    else {
16230      t = parent.predicate("fhir:"+parentType+'.'+name);
16231    }
16232    composeBackboneElement(t, "qualifiedInterval", name, element, index);
16233    if (element.hasCategoryElement()) {
16234      composeEnum(t, "ObservationDefinitionQualifiedIntervalComponent", "category", element.getCategoryElement(), -1);
16235    }
16236    if (element.hasRange()) {
16237      composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "range", element.getRange(), -1);
16238    }
16239    if (element.hasContext()) {
16240      composeCodeableConcept(t, "ObservationDefinitionQualifiedIntervalComponent", "context", element.getContext(), -1);
16241    }
16242    for (int i = 0; i < element.getAppliesTo().size(); i++) {
16243      composeCodeableConcept(t, "ObservationDefinitionQualifiedIntervalComponent", "appliesTo", element.getAppliesTo().get(i), i);
16244    }
16245    if (element.hasGenderElement()) {
16246      composeEnum(t, "ObservationDefinitionQualifiedIntervalComponent", "gender", element.getGenderElement(), -1);
16247    }
16248    if (element.hasAge()) {
16249      composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "age", element.getAge(), -1);
16250    }
16251    if (element.hasGestationalAge()) {
16252      composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "gestationalAge", element.getGestationalAge(), -1);
16253    }
16254    if (element.hasConditionElement()) {
16255      composeString(t, "ObservationDefinitionQualifiedIntervalComponent", "condition", element.getConditionElement(), -1);
16256    }
16257  }
16258
16259  protected void composeObservationDefinitionComponentComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionComponentComponent element, int index) {
16260    if (element == null) 
16261      return;
16262    Complex t;
16263    if (Utilities.noString(parentType))
16264      t = parent;
16265    else {
16266      t = parent.predicate("fhir:"+parentType+'.'+name);
16267    }
16268    composeBackboneElement(t, "component", name, element, index);
16269    if (element.hasCode()) {
16270      composeCodeableConcept(t, "ObservationDefinitionComponentComponent", "code", element.getCode(), -1);
16271    }
16272    for (int i = 0; i < element.getPermittedDataType().size(); i++) {
16273      composeEnum(t, "ObservationDefinitionComponentComponent", "permittedDataType", element.getPermittedDataType().get(i), i);
16274    }
16275    if (element.hasQuantitativeDetails()) {
16276      composeObservationDefinitionQuantitativeDetailsComponent(t, "ObservationDefinitionComponentComponent", "quantitativeDetails", element.getQuantitativeDetails(), -1);
16277    }
16278    for (int i = 0; i < element.getQualifiedInterval().size(); i++) {
16279      composeObservationDefinitionQualifiedIntervalComponent(t, "ObservationDefinitionComponentComponent", "qualifiedInterval", element.getQualifiedInterval().get(i), i);
16280    }
16281  }
16282
16283  protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition element, int index) {
16284    if (element == null) 
16285      return;
16286    Complex t;
16287    if (Utilities.noString(parentType))
16288      t = parent;
16289    else {
16290      t = parent.predicate("fhir:"+parentType+'.'+name);
16291    }
16292    composeCanonicalResource(t, "OperationDefinition", name, element, index);
16293    if (element.hasUrlElement()) {
16294      composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1);
16295    }
16296    if (element.hasVersionElement()) {
16297      composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1);
16298    }
16299    if (element.hasNameElement()) {
16300      composeString(t, "OperationDefinition", "name", element.getNameElement(), -1);
16301    }
16302    if (element.hasTitleElement()) {
16303      composeString(t, "OperationDefinition", "title", element.getTitleElement(), -1);
16304    }
16305    if (element.hasStatusElement()) {
16306      composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1);
16307    }
16308    if (element.hasKindElement()) {
16309      composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1);
16310    }
16311    if (element.hasExperimentalElement()) {
16312      composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1);
16313    }
16314    if (element.hasDateElement()) {
16315      composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1);
16316    }
16317    if (element.hasPublisherElement()) {
16318      composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1);
16319    }
16320    for (int i = 0; i < element.getContact().size(); i++) {
16321      composeContactDetail(t, "OperationDefinition", "contact", element.getContact().get(i), i);
16322    }
16323    if (element.hasDescriptionElement()) {
16324      composeMarkdown(t, "OperationDefinition", "description", element.getDescriptionElement(), -1);
16325    }
16326    for (int i = 0; i < element.getUseContext().size(); i++) {
16327      composeUsageContext(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i);
16328    }
16329    for (int i = 0; i < element.getJurisdiction().size(); i++) {
16330      composeCodeableConcept(t, "OperationDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
16331    }
16332    if (element.hasPurposeElement()) {
16333      composeMarkdown(t, "OperationDefinition", "purpose", element.getPurposeElement(), -1);
16334    }
16335    if (element.hasAffectsStateElement()) {
16336      composeBoolean(t, "OperationDefinition", "affectsState", element.getAffectsStateElement(), -1);
16337    }
16338    if (element.hasCodeElement()) {
16339      composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1);
16340    }
16341    if (element.hasCommentElement()) {
16342      composeMarkdown(t, "OperationDefinition", "comment", element.getCommentElement(), -1);
16343    }
16344    if (element.hasBaseElement()) {
16345      composeCanonical(t, "OperationDefinition", "base", element.getBaseElement(), -1);
16346    }
16347    for (int i = 0; i < element.getResource().size(); i++) {
16348      composeCode(t, "OperationDefinition", "resource", element.getResource().get(i), i);
16349    }
16350    if (element.hasSystemElement()) {
16351      composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1);
16352    }
16353    if (element.hasTypeElement()) {
16354      composeBoolean(t, "OperationDefinition", "type", element.getTypeElement(), -1);
16355    }
16356    if (element.hasInstanceElement()) {
16357      composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1);
16358    }
16359    if (element.hasInputProfileElement()) {
16360      composeCanonical(t, "OperationDefinition", "inputProfile", element.getInputProfileElement(), -1);
16361    }
16362    if (element.hasOutputProfileElement()) {
16363      composeCanonical(t, "OperationDefinition", "outputProfile", element.getOutputProfileElement(), -1);
16364    }
16365    for (int i = 0; i < element.getParameter().size(); i++) {
16366      composeOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i);
16367    }
16368    for (int i = 0; i < element.getOverload().size(); i++) {
16369      composeOperationDefinitionOverloadComponent(t, "OperationDefinition", "overload", element.getOverload().get(i), i);
16370    }
16371  }
16372
16373  protected void composeOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent element, int index) {
16374    if (element == null) 
16375      return;
16376    Complex t;
16377    if (Utilities.noString(parentType))
16378      t = parent;
16379    else {
16380      t = parent.predicate("fhir:"+parentType+'.'+name);
16381    }
16382    composeBackboneElement(t, "parameter", name, element, index);
16383    if (element.hasNameElement()) {
16384      composeCode(t, "OperationDefinitionParameterComponent", "name", element.getNameElement(), -1);
16385    }
16386    if (element.hasUseElement()) {
16387      composeEnum(t, "OperationDefinitionParameterComponent", "use", element.getUseElement(), -1);
16388    }
16389    if (element.hasMinElement()) {
16390      composeInteger(t, "OperationDefinitionParameterComponent", "min", element.getMinElement(), -1);
16391    }
16392    if (element.hasMaxElement()) {
16393      composeString(t, "OperationDefinitionParameterComponent", "max", element.getMaxElement(), -1);
16394    }
16395    if (element.hasDocumentationElement()) {
16396      composeString(t, "OperationDefinitionParameterComponent", "documentation", element.getDocumentationElement(), -1);
16397    }
16398    if (element.hasTypeElement()) {
16399      composeEnum(t, "OperationDefinitionParameterComponent", "type", element.getTypeElement(), -1);
16400    }
16401    for (int i = 0; i < element.getTargetProfile().size(); i++) {
16402      composeCanonical(t, "OperationDefinitionParameterComponent", "targetProfile", element.getTargetProfile().get(i), i);
16403    }
16404    if (element.hasSearchTypeElement()) {
16405      composeEnum(t, "OperationDefinitionParameterComponent", "searchType", element.getSearchTypeElement(), -1);
16406    }
16407    if (element.hasBinding()) {
16408      composeOperationDefinitionParameterBindingComponent(t, "OperationDefinitionParameterComponent", "binding", element.getBinding(), -1);
16409    }
16410    for (int i = 0; i < element.getReferencedFrom().size(); i++) {
16411      composeOperationDefinitionParameterReferencedFromComponent(t, "OperationDefinitionParameterComponent", "referencedFrom", element.getReferencedFrom().get(i), i);
16412    }
16413    for (int i = 0; i < element.getPart().size(); i++) {
16414      composeOperationDefinitionParameterComponent(t, "OperationDefinitionParameterComponent", "part", element.getPart().get(i), i);
16415    }
16416  }
16417
16418  protected void composeOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent element, int index) {
16419    if (element == null) 
16420      return;
16421    Complex t;
16422    if (Utilities.noString(parentType))
16423      t = parent;
16424    else {
16425      t = parent.predicate("fhir:"+parentType+'.'+name);
16426    }
16427    composeBackboneElement(t, "binding", name, element, index);
16428    if (element.hasStrengthElement()) {
16429      composeEnum(t, "OperationDefinitionParameterBindingComponent", "strength", element.getStrengthElement(), -1);
16430    }
16431    if (element.hasValueSetElement()) {
16432      composeCanonical(t, "OperationDefinitionParameterBindingComponent", "valueSet", element.getValueSetElement(), -1);
16433    }
16434  }
16435
16436  protected void composeOperationDefinitionParameterReferencedFromComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterReferencedFromComponent element, int index) {
16437    if (element == null) 
16438      return;
16439    Complex t;
16440    if (Utilities.noString(parentType))
16441      t = parent;
16442    else {
16443      t = parent.predicate("fhir:"+parentType+'.'+name);
16444    }
16445    composeBackboneElement(t, "referencedFrom", name, element, index);
16446    if (element.hasSourceElement()) {
16447      composeString(t, "OperationDefinitionParameterReferencedFromComponent", "source", element.getSourceElement(), -1);
16448    }
16449    if (element.hasSourceIdElement()) {
16450      composeString(t, "OperationDefinitionParameterReferencedFromComponent", "sourceId", element.getSourceIdElement(), -1);
16451    }
16452  }
16453
16454  protected void composeOperationDefinitionOverloadComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionOverloadComponent element, int index) {
16455    if (element == null) 
16456      return;
16457    Complex t;
16458    if (Utilities.noString(parentType))
16459      t = parent;
16460    else {
16461      t = parent.predicate("fhir:"+parentType+'.'+name);
16462    }
16463    composeBackboneElement(t, "overload", name, element, index);
16464    for (int i = 0; i < element.getParameterName().size(); i++) {
16465      composeString(t, "OperationDefinitionOverloadComponent", "parameterName", element.getParameterName().get(i), i);
16466    }
16467    if (element.hasCommentElement()) {
16468      composeString(t, "OperationDefinitionOverloadComponent", "comment", element.getCommentElement(), -1);
16469    }
16470  }
16471
16472  protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome element, int index) {
16473    if (element == null) 
16474      return;
16475    Complex t;
16476    if (Utilities.noString(parentType))
16477      t = parent;
16478    else {
16479      t = parent.predicate("fhir:"+parentType+'.'+name);
16480    }
16481    composeDomainResource(t, "OperationOutcome", name, element, index);
16482    for (int i = 0; i < element.getIssue().size(); i++) {
16483      composeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i);
16484    }
16485  }
16486
16487  protected void composeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent element, int index) {
16488    if (element == null) 
16489      return;
16490    Complex t;
16491    if (Utilities.noString(parentType))
16492      t = parent;
16493    else {
16494      t = parent.predicate("fhir:"+parentType+'.'+name);
16495    }
16496    composeBackboneElement(t, "issue", name, element, index);
16497    if (element.hasSeverityElement()) {
16498      composeEnum(t, "OperationOutcomeIssueComponent", "severity", element.getSeverityElement(), -1);
16499    }
16500    if (element.hasCodeElement()) {
16501      composeEnum(t, "OperationOutcomeIssueComponent", "code", element.getCodeElement(), -1);
16502    }
16503    if (element.hasDetails()) {
16504      composeCodeableConcept(t, "OperationOutcomeIssueComponent", "details", element.getDetails(), -1);
16505    }
16506    if (element.hasDiagnosticsElement()) {
16507      composeString(t, "OperationOutcomeIssueComponent", "diagnostics", element.getDiagnosticsElement(), -1);
16508    }
16509    for (int i = 0; i < element.getLocation().size(); i++) {
16510      composeString(t, "OperationOutcomeIssueComponent", "location", element.getLocation().get(i), i);
16511    }
16512    for (int i = 0; i < element.getExpression().size(); i++) {
16513      composeString(t, "OperationOutcomeIssueComponent", "expression", element.getExpression().get(i), i);
16514    }
16515  }
16516
16517  protected void composeOrganization(Complex parent, String parentType, String name, Organization element, int index) {
16518    if (element == null) 
16519      return;
16520    Complex t;
16521    if (Utilities.noString(parentType))
16522      t = parent;
16523    else {
16524      t = parent.predicate("fhir:"+parentType+'.'+name);
16525    }
16526    composeDomainResource(t, "Organization", name, element, index);
16527    for (int i = 0; i < element.getIdentifier().size(); i++) {
16528      composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i);
16529    }
16530    if (element.hasActiveElement()) {
16531      composeBoolean(t, "Organization", "active", element.getActiveElement(), -1);
16532    }
16533    for (int i = 0; i < element.getType().size(); i++) {
16534      composeCodeableConcept(t, "Organization", "type", element.getType().get(i), i);
16535    }
16536    if (element.hasNameElement()) {
16537      composeString(t, "Organization", "name", element.getNameElement(), -1);
16538    }
16539    for (int i = 0; i < element.getAlias().size(); i++) {
16540      composeString(t, "Organization", "alias", element.getAlias().get(i), i);
16541    }
16542    for (int i = 0; i < element.getTelecom().size(); i++) {
16543      composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i);
16544    }
16545    for (int i = 0; i < element.getAddress().size(); i++) {
16546      composeAddress(t, "Organization", "address", element.getAddress().get(i), i);
16547    }
16548    if (element.hasPartOf()) {
16549      composeReference(t, "Organization", "partOf", element.getPartOf(), -1);
16550    }
16551    for (int i = 0; i < element.getContact().size(); i++) {
16552      composeOrganizationContactComponent(t, "Organization", "contact", element.getContact().get(i), i);
16553    }
16554    for (int i = 0; i < element.getEndpoint().size(); i++) {
16555      composeReference(t, "Organization", "endpoint", element.getEndpoint().get(i), i);
16556    }
16557  }
16558
16559  protected void composeOrganizationContactComponent(Complex parent, String parentType, String name, Organization.OrganizationContactComponent element, int index) {
16560    if (element == null) 
16561      return;
16562    Complex t;
16563    if (Utilities.noString(parentType))
16564      t = parent;
16565    else {
16566      t = parent.predicate("fhir:"+parentType+'.'+name);
16567    }
16568    composeBackboneElement(t, "contact", name, element, index);
16569    if (element.hasPurpose()) {
16570      composeCodeableConcept(t, "OrganizationContactComponent", "purpose", element.getPurpose(), -1);
16571    }
16572    if (element.hasName()) {
16573      composeHumanName(t, "OrganizationContactComponent", "name", element.getName(), -1);
16574    }
16575    for (int i = 0; i < element.getTelecom().size(); i++) {
16576      composeContactPoint(t, "OrganizationContactComponent", "telecom", element.getTelecom().get(i), i);
16577    }
16578    if (element.hasAddress()) {
16579      composeAddress(t, "OrganizationContactComponent", "address", element.getAddress(), -1);
16580    }
16581  }
16582
16583  protected void composeOrganizationAffiliation(Complex parent, String parentType, String name, OrganizationAffiliation 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    composeDomainResource(t, "OrganizationAffiliation", name, element, index);
16593    for (int i = 0; i < element.getIdentifier().size(); i++) {
16594      composeIdentifier(t, "OrganizationAffiliation", "identifier", element.getIdentifier().get(i), i);
16595    }
16596    if (element.hasActiveElement()) {
16597      composeBoolean(t, "OrganizationAffiliation", "active", element.getActiveElement(), -1);
16598    }
16599    if (element.hasPeriod()) {
16600      composePeriod(t, "OrganizationAffiliation", "period", element.getPeriod(), -1);
16601    }
16602    if (element.hasOrganization()) {
16603      composeReference(t, "OrganizationAffiliation", "organization", element.getOrganization(), -1);
16604    }
16605    if (element.hasParticipatingOrganization()) {
16606      composeReference(t, "OrganizationAffiliation", "participatingOrganization", element.getParticipatingOrganization(), -1);
16607    }
16608    for (int i = 0; i < element.getNetwork().size(); i++) {
16609      composeReference(t, "OrganizationAffiliation", "network", element.getNetwork().get(i), i);
16610    }
16611    for (int i = 0; i < element.getCode().size(); i++) {
16612      composeCodeableConcept(t, "OrganizationAffiliation", "code", element.getCode().get(i), i);
16613    }
16614    for (int i = 0; i < element.getSpecialty().size(); i++) {
16615      composeCodeableConcept(t, "OrganizationAffiliation", "specialty", element.getSpecialty().get(i), i);
16616    }
16617    for (int i = 0; i < element.getLocation().size(); i++) {
16618      composeReference(t, "OrganizationAffiliation", "location", element.getLocation().get(i), i);
16619    }
16620    for (int i = 0; i < element.getHealthcareService().size(); i++) {
16621      composeReference(t, "OrganizationAffiliation", "healthcareService", element.getHealthcareService().get(i), i);
16622    }
16623    for (int i = 0; i < element.getTelecom().size(); i++) {
16624      composeContactPoint(t, "OrganizationAffiliation", "telecom", element.getTelecom().get(i), i);
16625    }
16626    for (int i = 0; i < element.getEndpoint().size(); i++) {
16627      composeReference(t, "OrganizationAffiliation", "endpoint", element.getEndpoint().get(i), i);
16628    }
16629  }
16630
16631  protected void composePackagedProductDefinition(Complex parent, String parentType, String name, PackagedProductDefinition element, int index) {
16632    if (element == null) 
16633      return;
16634    Complex t;
16635    if (Utilities.noString(parentType))
16636      t = parent;
16637    else {
16638      t = parent.predicate("fhir:"+parentType+'.'+name);
16639    }
16640    composeDomainResource(t, "PackagedProductDefinition", name, element, index);
16641    for (int i = 0; i < element.getIdentifier().size(); i++) {
16642      composeIdentifier(t, "PackagedProductDefinition", "identifier", element.getIdentifier().get(i), i);
16643    }
16644    for (int i = 0; i < element.getSubject().size(); i++) {
16645      composeReference(t, "PackagedProductDefinition", "subject", element.getSubject().get(i), i);
16646    }
16647    if (element.hasDescriptionElement()) {
16648      composeString(t, "PackagedProductDefinition", "description", element.getDescriptionElement(), -1);
16649    }
16650    if (element.hasLegalStatusOfSupply()) {
16651      composeCodeableConcept(t, "PackagedProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1);
16652    }
16653    for (int i = 0; i < element.getMarketingStatus().size(); i++) {
16654      composeMarketingStatus(t, "PackagedProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i);
16655    }
16656    if (element.hasCopackagedIndicatorElement()) {
16657      composeBoolean(t, "PackagedProductDefinition", "copackagedIndicator", element.getCopackagedIndicatorElement(), -1);
16658    }
16659    if (element.hasMarketingAuthorization()) {
16660      composeReference(t, "PackagedProductDefinition", "marketingAuthorization", element.getMarketingAuthorization(), -1);
16661    }
16662    for (int i = 0; i < element.getManufacturer().size(); i++) {
16663      composeReference(t, "PackagedProductDefinition", "manufacturer", element.getManufacturer().get(i), i);
16664    }
16665    for (int i = 0; i < element.getBatchIdentifier().size(); i++) {
16666      composePackagedProductDefinitionBatchIdentifierComponent(t, "PackagedProductDefinition", "batchIdentifier", element.getBatchIdentifier().get(i), i);
16667    }
16668    for (int i = 0; i < element.getPackage().size(); i++) {
16669      composePackagedProductDefinitionPackageComponent(t, "PackagedProductDefinition", "package", element.getPackage().get(i), i);
16670    }
16671  }
16672
16673  protected void composePackagedProductDefinitionBatchIdentifierComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionBatchIdentifierComponent element, int index) {
16674    if (element == null) 
16675      return;
16676    Complex t;
16677    if (Utilities.noString(parentType))
16678      t = parent;
16679    else {
16680      t = parent.predicate("fhir:"+parentType+'.'+name);
16681    }
16682    composeBackboneElement(t, "batchIdentifier", name, element, index);
16683    if (element.hasOuterPackaging()) {
16684      composeIdentifier(t, "PackagedProductDefinitionBatchIdentifierComponent", "outerPackaging", element.getOuterPackaging(), -1);
16685    }
16686    if (element.hasImmediatePackaging()) {
16687      composeIdentifier(t, "PackagedProductDefinitionBatchIdentifierComponent", "immediatePackaging", element.getImmediatePackaging(), -1);
16688    }
16689  }
16690
16691  protected void composePackagedProductDefinitionPackageComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageComponent element, int index) {
16692    if (element == null) 
16693      return;
16694    Complex t;
16695    if (Utilities.noString(parentType))
16696      t = parent;
16697    else {
16698      t = parent.predicate("fhir:"+parentType+'.'+name);
16699    }
16700    composeBackboneElement(t, "package", name, element, index);
16701    for (int i = 0; i < element.getIdentifier().size(); i++) {
16702      composeIdentifier(t, "PackagedProductDefinitionPackageComponent", "identifier", element.getIdentifier().get(i), i);
16703    }
16704    if (element.hasType()) {
16705      composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "type", element.getType(), -1);
16706    }
16707    if (element.hasQuantity()) {
16708      composeQuantity(t, "PackagedProductDefinitionPackageComponent", "quantity", element.getQuantity(), -1);
16709    }
16710    for (int i = 0; i < element.getMaterial().size(); i++) {
16711      composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "material", element.getMaterial().get(i), i);
16712    }
16713    for (int i = 0; i < element.getAlternateMaterial().size(); i++) {
16714      composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "alternateMaterial", element.getAlternateMaterial().get(i), i);
16715    }
16716    for (int i = 0; i < element.getShelfLifeStorage().size(); i++) {
16717      composeProductShelfLife(t, "PackagedProductDefinitionPackageComponent", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i);
16718    }
16719    for (int i = 0; i < element.getManufacturer().size(); i++) {
16720      composeReference(t, "PackagedProductDefinitionPackageComponent", "manufacturer", element.getManufacturer().get(i), i);
16721    }
16722    for (int i = 0; i < element.getCharacteristic().size(); i++) {
16723      composePackagedProductDefinitionPackageCharacteristicComponent(t, "PackagedProductDefinitionPackageComponent", "characteristic", element.getCharacteristic().get(i), i);
16724    }
16725    for (int i = 0; i < element.getContainedItem().size(); i++) {
16726      composePackagedProductDefinitionPackageContainedItemComponent(t, "PackagedProductDefinitionPackageComponent", "containedItem", element.getContainedItem().get(i), i);
16727    }
16728    for (int i = 0; i < element.getPackage().size(); i++) {
16729      composePackagedProductDefinitionPackageComponent(t, "PackagedProductDefinitionPackageComponent", "package", element.getPackage().get(i), i);
16730    }
16731  }
16732
16733  protected void composePackagedProductDefinitionPackageCharacteristicComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageCharacteristicComponent element, int index) {
16734    if (element == null) 
16735      return;
16736    Complex t;
16737    if (Utilities.noString(parentType))
16738      t = parent;
16739    else {
16740      t = parent.predicate("fhir:"+parentType+'.'+name);
16741    }
16742    composeBackboneElement(t, "characteristic", name, element, index);
16743    if (element.hasCode()) {
16744      composeCodeableConcept(t, "PackagedProductDefinitionPackageCharacteristicComponent", "code", element.getCode(), -1);
16745    }
16746    if (element.hasValue()) {
16747      composeType(t, "PackagedProductDefinitionPackageCharacteristicComponent", "value", element.getValue(), -1);
16748    }
16749  }
16750
16751  protected void composePackagedProductDefinitionPackageContainedItemComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageContainedItemComponent element, int index) {
16752    if (element == null) 
16753      return;
16754    Complex t;
16755    if (Utilities.noString(parentType))
16756      t = parent;
16757    else {
16758      t = parent.predicate("fhir:"+parentType+'.'+name);
16759    }
16760    composeBackboneElement(t, "containedItem", name, element, index);
16761    for (int i = 0; i < element.getItem().size(); i++) {
16762      composeReference(t, "PackagedProductDefinitionPackageContainedItemComponent", "item", element.getItem().get(i), i);
16763    }
16764    if (element.hasAmount()) {
16765      composeType(t, "PackagedProductDefinitionPackageContainedItemComponent", "amount", element.getAmount(), -1);
16766    }
16767  }
16768
16769  protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) {
16770    if (element == null) 
16771      return;
16772    Complex t;
16773    if (Utilities.noString(parentType))
16774      t = parent;
16775    else {
16776      t = parent.predicate("fhir:"+parentType+'.'+name);
16777    }
16778    composeResource(t, "Parameters", name, element, index);
16779    for (int i = 0; i < element.getParameter().size(); i++) {
16780      composeParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i);
16781    }
16782  }
16783
16784  protected void composeParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) {
16785    if (element == null) 
16786      return;
16787    Complex t;
16788    if (Utilities.noString(parentType))
16789      t = parent;
16790    else {
16791      t = parent.predicate("fhir:"+parentType+'.'+name);
16792    }
16793    composeBackboneElement(t, "parameter", name, element, index);
16794    if (element.hasNameElement()) {
16795      composeString(t, "ParametersParameterComponent", "name", element.getNameElement(), -1);
16796    }
16797    if (element.hasValue()) {
16798      composeType(t, "ParametersParameterComponent", "value", element.getValue(), -1);
16799    }
16800    if (element.hasResource()) {
16801      composeResource(t, "ParametersParameterComponent", "resource", element.getResource(), -1);
16802    }
16803    for (int i = 0; i < element.getPart().size(); i++) {
16804      composeParametersParameterComponent(t, "ParametersParameterComponent", "part", element.getPart().get(i), i);
16805    }
16806  }
16807
16808  protected void composePatient(Complex parent, String parentType, String name, Patient element, int index) {
16809    if (element == null) 
16810      return;
16811    Complex t;
16812    if (Utilities.noString(parentType))
16813      t = parent;
16814    else {
16815      t = parent.predicate("fhir:"+parentType+'.'+name);
16816    }
16817    composeDomainResource(t, "Patient", name, element, index);
16818    for (int i = 0; i < element.getIdentifier().size(); i++) {
16819      composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i);
16820    }
16821    if (element.hasActiveElement()) {
16822      composeBoolean(t, "Patient", "active", element.getActiveElement(), -1);
16823    }
16824    for (int i = 0; i < element.getName().size(); i++) {
16825      composeHumanName(t, "Patient", "name", element.getName().get(i), i);
16826    }
16827    for (int i = 0; i < element.getTelecom().size(); i++) {
16828      composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i);
16829    }
16830    if (element.hasGenderElement()) {
16831      composeEnum(t, "Patient", "gender", element.getGenderElement(), -1);
16832    }
16833    if (element.hasBirthDateElement()) {
16834      composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1);
16835    }
16836    if (element.hasDeceased()) {
16837      composeType(t, "Patient", "deceased", element.getDeceased(), -1);
16838    }
16839    for (int i = 0; i < element.getAddress().size(); i++) {
16840      composeAddress(t, "Patient", "address", element.getAddress().get(i), i);
16841    }
16842    if (element.hasMaritalStatus()) {
16843      composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1);
16844    }
16845    if (element.hasMultipleBirth()) {
16846      composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1);
16847    }
16848    for (int i = 0; i < element.getPhoto().size(); i++) {
16849      composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i);
16850    }
16851    for (int i = 0; i < element.getContact().size(); i++) {
16852      composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i);
16853    }
16854    for (int i = 0; i < element.getCommunication().size(); i++) {
16855      composePatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i);
16856    }
16857    for (int i = 0; i < element.getGeneralPractitioner().size(); i++) {
16858      composeReference(t, "Patient", "generalPractitioner", element.getGeneralPractitioner().get(i), i);
16859    }
16860    if (element.hasManagingOrganization()) {
16861      composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1);
16862    }
16863    for (int i = 0; i < element.getLink().size(); i++) {
16864      composePatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i);
16865    }
16866  }
16867
16868  protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent 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, "contact", name, element, index);
16878    for (int i = 0; i < element.getRelationship().size(); i++) {
16879      composeCodeableConcept(t, "ContactComponent", "relationship", element.getRelationship().get(i), i);
16880    }
16881    if (element.hasName()) {
16882      composeHumanName(t, "ContactComponent", "name", element.getName(), -1);
16883    }
16884    for (int i = 0; i < element.getTelecom().size(); i++) {
16885      composeContactPoint(t, "ContactComponent", "telecom", element.getTelecom().get(i), i);
16886    }
16887    if (element.hasAddress()) {
16888      composeAddress(t, "ContactComponent", "address", element.getAddress(), -1);
16889    }
16890    if (element.hasGenderElement()) {
16891      composeEnum(t, "ContactComponent", "gender", element.getGenderElement(), -1);
16892    }
16893    if (element.hasOrganization()) {
16894      composeReference(t, "ContactComponent", "organization", element.getOrganization(), -1);
16895    }
16896    if (element.hasPeriod()) {
16897      composePeriod(t, "ContactComponent", "period", element.getPeriod(), -1);
16898    }
16899  }
16900
16901  protected void composePatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent element, int index) {
16902    if (element == null) 
16903      return;
16904    Complex t;
16905    if (Utilities.noString(parentType))
16906      t = parent;
16907    else {
16908      t = parent.predicate("fhir:"+parentType+'.'+name);
16909    }
16910    composeBackboneElement(t, "communication", name, element, index);
16911    if (element.hasLanguage()) {
16912      composeCodeableConcept(t, "PatientCommunicationComponent", "language", element.getLanguage(), -1);
16913    }
16914    if (element.hasPreferredElement()) {
16915      composeBoolean(t, "PatientCommunicationComponent", "preferred", element.getPreferredElement(), -1);
16916    }
16917  }
16918
16919  protected void composePatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent element, int index) {
16920    if (element == null) 
16921      return;
16922    Complex t;
16923    if (Utilities.noString(parentType))
16924      t = parent;
16925    else {
16926      t = parent.predicate("fhir:"+parentType+'.'+name);
16927    }
16928    composeBackboneElement(t, "link", name, element, index);
16929    if (element.hasOther()) {
16930      composeReference(t, "PatientLinkComponent", "other", element.getOther(), -1);
16931    }
16932    if (element.hasTypeElement()) {
16933      composeEnum(t, "PatientLinkComponent", "type", element.getTypeElement(), -1);
16934    }
16935  }
16936
16937  protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice element, int index) {
16938    if (element == null) 
16939      return;
16940    Complex t;
16941    if (Utilities.noString(parentType))
16942      t = parent;
16943    else {
16944      t = parent.predicate("fhir:"+parentType+'.'+name);
16945    }
16946    composeDomainResource(t, "PaymentNotice", name, element, index);
16947    for (int i = 0; i < element.getIdentifier().size(); i++) {
16948      composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i);
16949    }
16950    if (element.hasStatusElement()) {
16951      composeEnum(t, "PaymentNotice", "status", element.getStatusElement(), -1);
16952    }
16953    if (element.hasRequest()) {
16954      composeReference(t, "PaymentNotice", "request", element.getRequest(), -1);
16955    }
16956    if (element.hasResponse()) {
16957      composeReference(t, "PaymentNotice", "response", element.getResponse(), -1);
16958    }
16959    if (element.hasCreatedElement()) {
16960      composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1);
16961    }
16962    if (element.hasProvider()) {
16963      composeReference(t, "PaymentNotice", "provider", element.getProvider(), -1);
16964    }
16965    if (element.hasPayment()) {
16966      composeReference(t, "PaymentNotice", "payment", element.getPayment(), -1);
16967    }
16968    if (element.hasPaymentDateElement()) {
16969      composeDate(t, "PaymentNotice", "paymentDate", element.getPaymentDateElement(), -1);
16970    }
16971    if (element.hasPayee()) {
16972      composeReference(t, "PaymentNotice", "payee", element.getPayee(), -1);
16973    }
16974    if (element.hasRecipient()) {
16975      composeReference(t, "PaymentNotice", "recipient", element.getRecipient(), -1);
16976    }
16977    if (element.hasAmount()) {
16978      composeMoney(t, "PaymentNotice", "amount", element.getAmount(), -1);
16979    }
16980    if (element.hasPaymentStatus()) {
16981      composeCodeableConcept(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1);
16982    }
16983  }
16984
16985  protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation 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, "PaymentReconciliation", name, element, index);
16995    for (int i = 0; i < element.getIdentifier().size(); i++) {
16996      composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i);
16997    }
16998    if (element.hasStatusElement()) {
16999      composeEnum(t, "PaymentReconciliation", "status", element.getStatusElement(), -1);
17000    }
17001    if (element.hasPeriod()) {
17002      composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1);
17003    }
17004    if (element.hasCreatedElement()) {
17005      composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1);
17006    }
17007    if (element.hasPaymentIssuer()) {
17008      composeReference(t, "PaymentReconciliation", "paymentIssuer", element.getPaymentIssuer(), -1);
17009    }
17010    if (element.hasRequest()) {
17011      composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1);
17012    }
17013    if (element.hasRequestor()) {
17014      composeReference(t, "PaymentReconciliation", "requestor", element.getRequestor(), -1);
17015    }
17016    if (element.hasOutcomeElement()) {
17017      composeEnum(t, "PaymentReconciliation", "outcome", element.getOutcomeElement(), -1);
17018    }
17019    if (element.hasDispositionElement()) {
17020      composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1);
17021    }
17022    if (element.hasPaymentDateElement()) {
17023      composeDate(t, "PaymentReconciliation", "paymentDate", element.getPaymentDateElement(), -1);
17024    }
17025    if (element.hasPaymentAmount()) {
17026      composeMoney(t, "PaymentReconciliation", "paymentAmount", element.getPaymentAmount(), -1);
17027    }
17028    if (element.hasPaymentIdentifier()) {
17029      composeIdentifier(t, "PaymentReconciliation", "paymentIdentifier", element.getPaymentIdentifier(), -1);
17030    }
17031    for (int i = 0; i < element.getDetail().size(); i++) {
17032      composePaymentReconciliationDetailsComponent(t, "PaymentReconciliation", "detail", element.getDetail().get(i), i);
17033    }
17034    if (element.hasFormCode()) {
17035      composeCodeableConcept(t, "PaymentReconciliation", "formCode", element.getFormCode(), -1);
17036    }
17037    for (int i = 0; i < element.getProcessNote().size(); i++) {
17038      composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "processNote", element.getProcessNote().get(i), i);
17039    }
17040  }
17041
17042  protected void composePaymentReconciliationDetailsComponent(Complex parent, String parentType, String name, PaymentReconciliation.DetailsComponent element, int index) {
17043    if (element == null) 
17044      return;
17045    Complex t;
17046    if (Utilities.noString(parentType))
17047      t = parent;
17048    else {
17049      t = parent.predicate("fhir:"+parentType+'.'+name);
17050    }
17051    composeBackboneElement(t, "detail", name, element, index);
17052    if (element.hasIdentifier()) {
17053      composeIdentifier(t, "DetailsComponent", "identifier", element.getIdentifier(), -1);
17054    }
17055    if (element.hasPredecessor()) {
17056      composeIdentifier(t, "DetailsComponent", "predecessor", element.getPredecessor(), -1);
17057    }
17058    if (element.hasType()) {
17059      composeCodeableConcept(t, "DetailsComponent", "type", element.getType(), -1);
17060    }
17061    if (element.hasRequest()) {
17062      composeReference(t, "DetailsComponent", "request", element.getRequest(), -1);
17063    }
17064    if (element.hasSubmitter()) {
17065      composeReference(t, "DetailsComponent", "submitter", element.getSubmitter(), -1);
17066    }
17067    if (element.hasResponse()) {
17068      composeReference(t, "DetailsComponent", "response", element.getResponse(), -1);
17069    }
17070    if (element.hasDateElement()) {
17071      composeDate(t, "DetailsComponent", "date", element.getDateElement(), -1);
17072    }
17073    if (element.hasResponsible()) {
17074      composeReference(t, "DetailsComponent", "responsible", element.getResponsible(), -1);
17075    }
17076    if (element.hasPayee()) {
17077      composeReference(t, "DetailsComponent", "payee", element.getPayee(), -1);
17078    }
17079    if (element.hasAmount()) {
17080      composeMoney(t, "DetailsComponent", "amount", element.getAmount(), -1);
17081    }
17082  }
17083
17084  protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent element, int index) {
17085    if (element == null) 
17086      return;
17087    Complex t;
17088    if (Utilities.noString(parentType))
17089      t = parent;
17090    else {
17091      t = parent.predicate("fhir:"+parentType+'.'+name);
17092    }
17093    composeBackboneElement(t, "processNote", name, element, index);
17094    if (element.hasTypeElement()) {
17095      composeEnum(t, "NotesComponent", "type", element.getTypeElement(), -1);
17096    }
17097    if (element.hasTextElement()) {
17098      composeString(t, "NotesComponent", "text", element.getTextElement(), -1);
17099    }
17100  }
17101
17102  protected void composePerson(Complex parent, String parentType, String name, Person element, int index) {
17103    if (element == null) 
17104      return;
17105    Complex t;
17106    if (Utilities.noString(parentType))
17107      t = parent;
17108    else {
17109      t = parent.predicate("fhir:"+parentType+'.'+name);
17110    }
17111    composeDomainResource(t, "Person", name, element, index);
17112    for (int i = 0; i < element.getIdentifier().size(); i++) {
17113      composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i);
17114    }
17115    for (int i = 0; i < element.getName().size(); i++) {
17116      composeHumanName(t, "Person", "name", element.getName().get(i), i);
17117    }
17118    for (int i = 0; i < element.getTelecom().size(); i++) {
17119      composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i);
17120    }
17121    if (element.hasGenderElement()) {
17122      composeEnum(t, "Person", "gender", element.getGenderElement(), -1);
17123    }
17124    if (element.hasBirthDateElement()) {
17125      composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1);
17126    }
17127    for (int i = 0; i < element.getAddress().size(); i++) {
17128      composeAddress(t, "Person", "address", element.getAddress().get(i), i);
17129    }
17130    if (element.hasPhoto()) {
17131      composeAttachment(t, "Person", "photo", element.getPhoto(), -1);
17132    }
17133    if (element.hasManagingOrganization()) {
17134      composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1);
17135    }
17136    if (element.hasActiveElement()) {
17137      composeBoolean(t, "Person", "active", element.getActiveElement(), -1);
17138    }
17139    for (int i = 0; i < element.getLink().size(); i++) {
17140      composePersonLinkComponent(t, "Person", "link", element.getLink().get(i), i);
17141    }
17142  }
17143
17144  protected void composePersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent element, int index) {
17145    if (element == null) 
17146      return;
17147    Complex t;
17148    if (Utilities.noString(parentType))
17149      t = parent;
17150    else {
17151      t = parent.predicate("fhir:"+parentType+'.'+name);
17152    }
17153    composeBackboneElement(t, "link", name, element, index);
17154    if (element.hasTarget()) {
17155      composeReference(t, "PersonLinkComponent", "target", element.getTarget(), -1);
17156    }
17157    if (element.hasAssuranceElement()) {
17158      composeEnum(t, "PersonLinkComponent", "assurance", element.getAssuranceElement(), -1);
17159    }
17160  }
17161
17162  protected void composePlanDefinition(Complex parent, String parentType, String name, PlanDefinition 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    composeMetadataResource(t, "PlanDefinition", name, element, index);
17172    if (element.hasUrlElement()) {
17173      composeUri(t, "PlanDefinition", "url", element.getUrlElement(), -1);
17174    }
17175    for (int i = 0; i < element.getIdentifier().size(); i++) {
17176      composeIdentifier(t, "PlanDefinition", "identifier", element.getIdentifier().get(i), i);
17177    }
17178    if (element.hasVersionElement()) {
17179      composeString(t, "PlanDefinition", "version", element.getVersionElement(), -1);
17180    }
17181    if (element.hasNameElement()) {
17182      composeString(t, "PlanDefinition", "name", element.getNameElement(), -1);
17183    }
17184    if (element.hasTitleElement()) {
17185      composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1);
17186    }
17187    if (element.hasSubtitleElement()) {
17188      composeString(t, "PlanDefinition", "subtitle", element.getSubtitleElement(), -1);
17189    }
17190    if (element.hasType()) {
17191      composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1);
17192    }
17193    if (element.hasStatusElement()) {
17194      composeEnum(t, "PlanDefinition", "status", element.getStatusElement(), -1);
17195    }
17196    if (element.hasExperimentalElement()) {
17197      composeBoolean(t, "PlanDefinition", "experimental", element.getExperimentalElement(), -1);
17198    }
17199    if (element.hasSubject()) {
17200      composeType(t, "PlanDefinition", "subject", element.getSubject(), -1);
17201    }
17202    if (element.hasDateElement()) {
17203      composeDateTime(t, "PlanDefinition", "date", element.getDateElement(), -1);
17204    }
17205    if (element.hasPublisherElement()) {
17206      composeString(t, "PlanDefinition", "publisher", element.getPublisherElement(), -1);
17207    }
17208    for (int i = 0; i < element.getContact().size(); i++) {
17209      composeContactDetail(t, "PlanDefinition", "contact", element.getContact().get(i), i);
17210    }
17211    if (element.hasDescriptionElement()) {
17212      composeMarkdown(t, "PlanDefinition", "description", element.getDescriptionElement(), -1);
17213    }
17214    for (int i = 0; i < element.getUseContext().size(); i++) {
17215      composeUsageContext(t, "PlanDefinition", "useContext", element.getUseContext().get(i), i);
17216    }
17217    for (int i = 0; i < element.getJurisdiction().size(); i++) {
17218      composeCodeableConcept(t, "PlanDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
17219    }
17220    if (element.hasPurposeElement()) {
17221      composeMarkdown(t, "PlanDefinition", "purpose", element.getPurposeElement(), -1);
17222    }
17223    if (element.hasUsageElement()) {
17224      composeString(t, "PlanDefinition", "usage", element.getUsageElement(), -1);
17225    }
17226    if (element.hasCopyrightElement()) {
17227      composeMarkdown(t, "PlanDefinition", "copyright", element.getCopyrightElement(), -1);
17228    }
17229    if (element.hasApprovalDateElement()) {
17230      composeDate(t, "PlanDefinition", "approvalDate", element.getApprovalDateElement(), -1);
17231    }
17232    if (element.hasLastReviewDateElement()) {
17233      composeDate(t, "PlanDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
17234    }
17235    if (element.hasEffectivePeriod()) {
17236      composePeriod(t, "PlanDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
17237    }
17238    for (int i = 0; i < element.getTopic().size(); i++) {
17239      composeCodeableConcept(t, "PlanDefinition", "topic", element.getTopic().get(i), i);
17240    }
17241    for (int i = 0; i < element.getAuthor().size(); i++) {
17242      composeContactDetail(t, "PlanDefinition", "author", element.getAuthor().get(i), i);
17243    }
17244    for (int i = 0; i < element.getEditor().size(); i++) {
17245      composeContactDetail(t, "PlanDefinition", "editor", element.getEditor().get(i), i);
17246    }
17247    for (int i = 0; i < element.getReviewer().size(); i++) {
17248      composeContactDetail(t, "PlanDefinition", "reviewer", element.getReviewer().get(i), i);
17249    }
17250    for (int i = 0; i < element.getEndorser().size(); i++) {
17251      composeContactDetail(t, "PlanDefinition", "endorser", element.getEndorser().get(i), i);
17252    }
17253    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
17254      composeRelatedArtifact(t, "PlanDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i);
17255    }
17256    for (int i = 0; i < element.getLibrary().size(); i++) {
17257      composeCanonical(t, "PlanDefinition", "library", element.getLibrary().get(i), i);
17258    }
17259    for (int i = 0; i < element.getGoal().size(); i++) {
17260      composePlanDefinitionGoalComponent(t, "PlanDefinition", "goal", element.getGoal().get(i), i);
17261    }
17262    for (int i = 0; i < element.getAction().size(); i++) {
17263      composePlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i);
17264    }
17265  }
17266
17267  protected void composePlanDefinitionGoalComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalComponent element, int index) {
17268    if (element == null) 
17269      return;
17270    Complex t;
17271    if (Utilities.noString(parentType))
17272      t = parent;
17273    else {
17274      t = parent.predicate("fhir:"+parentType+'.'+name);
17275    }
17276    composeBackboneElement(t, "goal", name, element, index);
17277    if (element.hasCategory()) {
17278      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "category", element.getCategory(), -1);
17279    }
17280    if (element.hasDescription()) {
17281      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "description", element.getDescription(), -1);
17282    }
17283    if (element.hasPriority()) {
17284      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "priority", element.getPriority(), -1);
17285    }
17286    if (element.hasStart()) {
17287      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "start", element.getStart(), -1);
17288    }
17289    for (int i = 0; i < element.getAddresses().size(); i++) {
17290      composeCodeableConcept(t, "PlanDefinitionGoalComponent", "addresses", element.getAddresses().get(i), i);
17291    }
17292    for (int i = 0; i < element.getDocumentation().size(); i++) {
17293      composeRelatedArtifact(t, "PlanDefinitionGoalComponent", "documentation", element.getDocumentation().get(i), i);
17294    }
17295    for (int i = 0; i < element.getTarget().size(); i++) {
17296      composePlanDefinitionGoalTargetComponent(t, "PlanDefinitionGoalComponent", "target", element.getTarget().get(i), i);
17297    }
17298  }
17299
17300  protected void composePlanDefinitionGoalTargetComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalTargetComponent element, int index) {
17301    if (element == null) 
17302      return;
17303    Complex t;
17304    if (Utilities.noString(parentType))
17305      t = parent;
17306    else {
17307      t = parent.predicate("fhir:"+parentType+'.'+name);
17308    }
17309    composeBackboneElement(t, "target", name, element, index);
17310    if (element.hasMeasure()) {
17311      composeCodeableConcept(t, "PlanDefinitionGoalTargetComponent", "measure", element.getMeasure(), -1);
17312    }
17313    if (element.hasDetail()) {
17314      composeType(t, "PlanDefinitionGoalTargetComponent", "detail", element.getDetail(), -1);
17315    }
17316    if (element.hasDue()) {
17317      composeDuration(t, "PlanDefinitionGoalTargetComponent", "due", element.getDue(), -1);
17318    }
17319  }
17320
17321  protected void composePlanDefinitionActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionComponent 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, "action", name, element, index);
17331    if (element.hasPrefixElement()) {
17332      composeString(t, "PlanDefinitionActionComponent", "prefix", element.getPrefixElement(), -1);
17333    }
17334    if (element.hasTitleElement()) {
17335      composeString(t, "PlanDefinitionActionComponent", "title", element.getTitleElement(), -1);
17336    }
17337    if (element.hasDescriptionElement()) {
17338      composeString(t, "PlanDefinitionActionComponent", "description", element.getDescriptionElement(), -1);
17339    }
17340    if (element.hasTextEquivalentElement()) {
17341      composeString(t, "PlanDefinitionActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1);
17342    }
17343    if (element.hasPriorityElement()) {
17344      composeEnum(t, "PlanDefinitionActionComponent", "priority", element.getPriorityElement(), -1);
17345    }
17346    for (int i = 0; i < element.getCode().size(); i++) {
17347      composeCodeableConcept(t, "PlanDefinitionActionComponent", "code", element.getCode().get(i), i);
17348    }
17349    for (int i = 0; i < element.getReason().size(); i++) {
17350      composeCodeableConcept(t, "PlanDefinitionActionComponent", "reason", element.getReason().get(i), i);
17351    }
17352    for (int i = 0; i < element.getDocumentation().size(); i++) {
17353      composeRelatedArtifact(t, "PlanDefinitionActionComponent", "documentation", element.getDocumentation().get(i), i);
17354    }
17355    for (int i = 0; i < element.getGoalId().size(); i++) {
17356      composeId(t, "PlanDefinitionActionComponent", "goalId", element.getGoalId().get(i), i);
17357    }
17358    if (element.hasSubject()) {
17359      composeType(t, "PlanDefinitionActionComponent", "subject", element.getSubject(), -1);
17360    }
17361    for (int i = 0; i < element.getTrigger().size(); i++) {
17362      composeTriggerDefinition(t, "PlanDefinitionActionComponent", "trigger", element.getTrigger().get(i), i);
17363    }
17364    for (int i = 0; i < element.getCondition().size(); i++) {
17365      composePlanDefinitionActionConditionComponent(t, "PlanDefinitionActionComponent", "condition", element.getCondition().get(i), i);
17366    }
17367    for (int i = 0; i < element.getInput().size(); i++) {
17368      composeDataRequirement(t, "PlanDefinitionActionComponent", "input", element.getInput().get(i), i);
17369    }
17370    for (int i = 0; i < element.getOutput().size(); i++) {
17371      composeDataRequirement(t, "PlanDefinitionActionComponent", "output", element.getOutput().get(i), i);
17372    }
17373    for (int i = 0; i < element.getRelatedAction().size(); i++) {
17374      composePlanDefinitionActionRelatedActionComponent(t, "PlanDefinitionActionComponent", "relatedAction", element.getRelatedAction().get(i), i);
17375    }
17376    if (element.hasTiming()) {
17377      composeType(t, "PlanDefinitionActionComponent", "timing", element.getTiming(), -1);
17378    }
17379    for (int i = 0; i < element.getParticipant().size(); i++) {
17380      composePlanDefinitionActionParticipantComponent(t, "PlanDefinitionActionComponent", "participant", element.getParticipant().get(i), i);
17381    }
17382    if (element.hasType()) {
17383      composeCodeableConcept(t, "PlanDefinitionActionComponent", "type", element.getType(), -1);
17384    }
17385    if (element.hasGroupingBehaviorElement()) {
17386      composeEnum(t, "PlanDefinitionActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1);
17387    }
17388    if (element.hasSelectionBehaviorElement()) {
17389      composeEnum(t, "PlanDefinitionActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1);
17390    }
17391    if (element.hasRequiredBehaviorElement()) {
17392      composeEnum(t, "PlanDefinitionActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1);
17393    }
17394    if (element.hasPrecheckBehaviorElement()) {
17395      composeEnum(t, "PlanDefinitionActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1);
17396    }
17397    if (element.hasCardinalityBehaviorElement()) {
17398      composeEnum(t, "PlanDefinitionActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1);
17399    }
17400    if (element.hasDefinition()) {
17401      composeType(t, "PlanDefinitionActionComponent", "definition", element.getDefinition(), -1);
17402    }
17403    if (element.hasTransformElement()) {
17404      composeCanonical(t, "PlanDefinitionActionComponent", "transform", element.getTransformElement(), -1);
17405    }
17406    for (int i = 0; i < element.getDynamicValue().size(); i++) {
17407      composePlanDefinitionActionDynamicValueComponent(t, "PlanDefinitionActionComponent", "dynamicValue", element.getDynamicValue().get(i), i);
17408    }
17409    for (int i = 0; i < element.getAction().size(); i++) {
17410      composePlanDefinitionActionComponent(t, "PlanDefinitionActionComponent", "action", element.getAction().get(i), i);
17411    }
17412  }
17413
17414  protected void composePlanDefinitionActionConditionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionConditionComponent element, int index) {
17415    if (element == null) 
17416      return;
17417    Complex t;
17418    if (Utilities.noString(parentType))
17419      t = parent;
17420    else {
17421      t = parent.predicate("fhir:"+parentType+'.'+name);
17422    }
17423    composeBackboneElement(t, "condition", name, element, index);
17424    if (element.hasKindElement()) {
17425      composeEnum(t, "PlanDefinitionActionConditionComponent", "kind", element.getKindElement(), -1);
17426    }
17427    if (element.hasExpression()) {
17428      composeExpression(t, "PlanDefinitionActionConditionComponent", "expression", element.getExpression(), -1);
17429    }
17430  }
17431
17432  protected void composePlanDefinitionActionRelatedActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionRelatedActionComponent element, int index) {
17433    if (element == null) 
17434      return;
17435    Complex t;
17436    if (Utilities.noString(parentType))
17437      t = parent;
17438    else {
17439      t = parent.predicate("fhir:"+parentType+'.'+name);
17440    }
17441    composeBackboneElement(t, "relatedAction", name, element, index);
17442    if (element.hasActionIdElement()) {
17443      composeId(t, "PlanDefinitionActionRelatedActionComponent", "actionId", element.getActionIdElement(), -1);
17444    }
17445    if (element.hasRelationshipElement()) {
17446      composeEnum(t, "PlanDefinitionActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1);
17447    }
17448    if (element.hasOffset()) {
17449      composeType(t, "PlanDefinitionActionRelatedActionComponent", "offset", element.getOffset(), -1);
17450    }
17451  }
17452
17453  protected void composePlanDefinitionActionParticipantComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionParticipantComponent element, int index) {
17454    if (element == null) 
17455      return;
17456    Complex t;
17457    if (Utilities.noString(parentType))
17458      t = parent;
17459    else {
17460      t = parent.predicate("fhir:"+parentType+'.'+name);
17461    }
17462    composeBackboneElement(t, "participant", name, element, index);
17463    if (element.hasTypeElement()) {
17464      composeEnum(t, "PlanDefinitionActionParticipantComponent", "type", element.getTypeElement(), -1);
17465    }
17466    if (element.hasRole()) {
17467      composeCodeableConcept(t, "PlanDefinitionActionParticipantComponent", "role", element.getRole(), -1);
17468    }
17469  }
17470
17471  protected void composePlanDefinitionActionDynamicValueComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionDynamicValueComponent element, int index) {
17472    if (element == null) 
17473      return;
17474    Complex t;
17475    if (Utilities.noString(parentType))
17476      t = parent;
17477    else {
17478      t = parent.predicate("fhir:"+parentType+'.'+name);
17479    }
17480    composeBackboneElement(t, "dynamicValue", name, element, index);
17481    if (element.hasPathElement()) {
17482      composeString(t, "PlanDefinitionActionDynamicValueComponent", "path", element.getPathElement(), -1);
17483    }
17484    if (element.hasExpression()) {
17485      composeExpression(t, "PlanDefinitionActionDynamicValueComponent", "expression", element.getExpression(), -1);
17486    }
17487  }
17488
17489  protected void composePractitioner(Complex parent, String parentType, String name, Practitioner element, int index) {
17490    if (element == null) 
17491      return;
17492    Complex t;
17493    if (Utilities.noString(parentType))
17494      t = parent;
17495    else {
17496      t = parent.predicate("fhir:"+parentType+'.'+name);
17497    }
17498    composeDomainResource(t, "Practitioner", name, element, index);
17499    for (int i = 0; i < element.getIdentifier().size(); i++) {
17500      composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i);
17501    }
17502    if (element.hasActiveElement()) {
17503      composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1);
17504    }
17505    for (int i = 0; i < element.getName().size(); i++) {
17506      composeHumanName(t, "Practitioner", "name", element.getName().get(i), i);
17507    }
17508    for (int i = 0; i < element.getTelecom().size(); i++) {
17509      composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i);
17510    }
17511    for (int i = 0; i < element.getAddress().size(); i++) {
17512      composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i);
17513    }
17514    if (element.hasGenderElement()) {
17515      composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1);
17516    }
17517    if (element.hasBirthDateElement()) {
17518      composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1);
17519    }
17520    for (int i = 0; i < element.getPhoto().size(); i++) {
17521      composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i);
17522    }
17523    for (int i = 0; i < element.getQualification().size(); i++) {
17524      composePractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i);
17525    }
17526    for (int i = 0; i < element.getCommunication().size(); i++) {
17527      composeCodeableConcept(t, "Practitioner", "communication", element.getCommunication().get(i), i);
17528    }
17529  }
17530
17531  protected void composePractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent element, int index) {
17532    if (element == null) 
17533      return;
17534    Complex t;
17535    if (Utilities.noString(parentType))
17536      t = parent;
17537    else {
17538      t = parent.predicate("fhir:"+parentType+'.'+name);
17539    }
17540    composeBackboneElement(t, "qualification", name, element, index);
17541    for (int i = 0; i < element.getIdentifier().size(); i++) {
17542      composeIdentifier(t, "PractitionerQualificationComponent", "identifier", element.getIdentifier().get(i), i);
17543    }
17544    if (element.hasCode()) {
17545      composeCodeableConcept(t, "PractitionerQualificationComponent", "code", element.getCode(), -1);
17546    }
17547    if (element.hasPeriod()) {
17548      composePeriod(t, "PractitionerQualificationComponent", "period", element.getPeriod(), -1);
17549    }
17550    if (element.hasIssuer()) {
17551      composeReference(t, "PractitionerQualificationComponent", "issuer", element.getIssuer(), -1);
17552    }
17553  }
17554
17555  protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole element, int index) {
17556    if (element == null) 
17557      return;
17558    Complex t;
17559    if (Utilities.noString(parentType))
17560      t = parent;
17561    else {
17562      t = parent.predicate("fhir:"+parentType+'.'+name);
17563    }
17564    composeDomainResource(t, "PractitionerRole", name, element, index);
17565    for (int i = 0; i < element.getIdentifier().size(); i++) {
17566      composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i);
17567    }
17568    if (element.hasActiveElement()) {
17569      composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1);
17570    }
17571    if (element.hasPeriod()) {
17572      composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1);
17573    }
17574    if (element.hasPractitioner()) {
17575      composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1);
17576    }
17577    if (element.hasOrganization()) {
17578      composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1);
17579    }
17580    for (int i = 0; i < element.getCode().size(); i++) {
17581      composeCodeableConcept(t, "PractitionerRole", "code", element.getCode().get(i), i);
17582    }
17583    for (int i = 0; i < element.getSpecialty().size(); i++) {
17584      composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i);
17585    }
17586    for (int i = 0; i < element.getLocation().size(); i++) {
17587      composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i);
17588    }
17589    for (int i = 0; i < element.getHealthcareService().size(); i++) {
17590      composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i);
17591    }
17592    for (int i = 0; i < element.getTelecom().size(); i++) {
17593      composeContactPoint(t, "PractitionerRole", "telecom", element.getTelecom().get(i), i);
17594    }
17595    for (int i = 0; i < element.getAvailableTime().size(); i++) {
17596      composePractitionerRoleAvailableTimeComponent(t, "PractitionerRole", "availableTime", element.getAvailableTime().get(i), i);
17597    }
17598    for (int i = 0; i < element.getNotAvailable().size(); i++) {
17599      composePractitionerRoleNotAvailableComponent(t, "PractitionerRole", "notAvailable", element.getNotAvailable().get(i), i);
17600    }
17601    if (element.hasAvailabilityExceptionsElement()) {
17602      composeString(t, "PractitionerRole", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1);
17603    }
17604    for (int i = 0; i < element.getEndpoint().size(); i++) {
17605      composeReference(t, "PractitionerRole", "endpoint", element.getEndpoint().get(i), i);
17606    }
17607  }
17608
17609  protected void composePractitionerRoleAvailableTimeComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleAvailableTimeComponent 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, "availableTime", name, element, index);
17619    for (int i = 0; i < element.getDaysOfWeek().size(); i++) {
17620      composeEnum(t, "PractitionerRoleAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i);
17621    }
17622    if (element.hasAllDayElement()) {
17623      composeBoolean(t, "PractitionerRoleAvailableTimeComponent", "allDay", element.getAllDayElement(), -1);
17624    }
17625    if (element.hasAvailableStartTimeElement()) {
17626      composeTime(t, "PractitionerRoleAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1);
17627    }
17628    if (element.hasAvailableEndTimeElement()) {
17629      composeTime(t, "PractitionerRoleAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1);
17630    }
17631  }
17632
17633  protected void composePractitionerRoleNotAvailableComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleNotAvailableComponent element, int index) {
17634    if (element == null) 
17635      return;
17636    Complex t;
17637    if (Utilities.noString(parentType))
17638      t = parent;
17639    else {
17640      t = parent.predicate("fhir:"+parentType+'.'+name);
17641    }
17642    composeBackboneElement(t, "notAvailable", name, element, index);
17643    if (element.hasDescriptionElement()) {
17644      composeString(t, "PractitionerRoleNotAvailableComponent", "description", element.getDescriptionElement(), -1);
17645    }
17646    if (element.hasDuring()) {
17647      composePeriod(t, "PractitionerRoleNotAvailableComponent", "during", element.getDuring(), -1);
17648    }
17649  }
17650
17651  protected void composeProcedure(Complex parent, String parentType, String name, Procedure element, int index) {
17652    if (element == null) 
17653      return;
17654    Complex t;
17655    if (Utilities.noString(parentType))
17656      t = parent;
17657    else {
17658      t = parent.predicate("fhir:"+parentType+'.'+name);
17659    }
17660    composeDomainResource(t, "Procedure", name, element, index);
17661    for (int i = 0; i < element.getIdentifier().size(); i++) {
17662      composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i);
17663    }
17664    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
17665      composeCanonical(t, "Procedure", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
17666    }
17667    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
17668      composeUri(t, "Procedure", "instantiatesUri", element.getInstantiatesUri().get(i), i);
17669    }
17670    for (int i = 0; i < element.getBasedOn().size(); i++) {
17671      composeReference(t, "Procedure", "basedOn", element.getBasedOn().get(i), i);
17672    }
17673    for (int i = 0; i < element.getPartOf().size(); i++) {
17674      composeReference(t, "Procedure", "partOf", element.getPartOf().get(i), i);
17675    }
17676    if (element.hasStatusElement()) {
17677      composeEnum(t, "Procedure", "status", element.getStatusElement(), -1);
17678    }
17679    if (element.hasStatusReason()) {
17680      composeCodeableConcept(t, "Procedure", "statusReason", element.getStatusReason(), -1);
17681    }
17682    for (int i = 0; i < element.getCategory().size(); i++) {
17683      composeCodeableConcept(t, "Procedure", "category", element.getCategory().get(i), i);
17684    }
17685    if (element.hasCode()) {
17686      composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1);
17687    }
17688    if (element.hasSubject()) {
17689      composeReference(t, "Procedure", "subject", element.getSubject(), -1);
17690    }
17691    if (element.hasEncounter()) {
17692      composeReference(t, "Procedure", "encounter", element.getEncounter(), -1);
17693    }
17694    if (element.hasOccurrence()) {
17695      composeType(t, "Procedure", "occurrence", element.getOccurrence(), -1);
17696    }
17697    if (element.hasRecordedElement()) {
17698      composeDateTime(t, "Procedure", "recorded", element.getRecordedElement(), -1);
17699    }
17700    if (element.hasRecorder()) {
17701      composeReference(t, "Procedure", "recorder", element.getRecorder(), -1);
17702    }
17703    if (element.hasReported()) {
17704      composeType(t, "Procedure", "reported", element.getReported(), -1);
17705    }
17706    for (int i = 0; i < element.getPerformer().size(); i++) {
17707      composeProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i);
17708    }
17709    if (element.hasLocation()) {
17710      composeReference(t, "Procedure", "location", element.getLocation(), -1);
17711    }
17712    for (int i = 0; i < element.getReason().size(); i++) {
17713      composeCodeableReference(t, "Procedure", "reason", element.getReason().get(i), i);
17714    }
17715    for (int i = 0; i < element.getBodySite().size(); i++) {
17716      composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i);
17717    }
17718    if (element.hasOutcome()) {
17719      composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1);
17720    }
17721    for (int i = 0; i < element.getReport().size(); i++) {
17722      composeReference(t, "Procedure", "report", element.getReport().get(i), i);
17723    }
17724    for (int i = 0; i < element.getComplication().size(); i++) {
17725      composeCodeableConcept(t, "Procedure", "complication", element.getComplication().get(i), i);
17726    }
17727    for (int i = 0; i < element.getComplicationDetail().size(); i++) {
17728      composeReference(t, "Procedure", "complicationDetail", element.getComplicationDetail().get(i), i);
17729    }
17730    for (int i = 0; i < element.getFollowUp().size(); i++) {
17731      composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i);
17732    }
17733    for (int i = 0; i < element.getNote().size(); i++) {
17734      composeAnnotation(t, "Procedure", "note", element.getNote().get(i), i);
17735    }
17736    for (int i = 0; i < element.getFocalDevice().size(); i++) {
17737      composeProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i);
17738    }
17739    for (int i = 0; i < element.getUsed().size(); i++) {
17740      composeCodeableReference(t, "Procedure", "used", element.getUsed().get(i), i);
17741    }
17742  }
17743
17744  protected void composeProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent element, int index) {
17745    if (element == null) 
17746      return;
17747    Complex t;
17748    if (Utilities.noString(parentType))
17749      t = parent;
17750    else {
17751      t = parent.predicate("fhir:"+parentType+'.'+name);
17752    }
17753    composeBackboneElement(t, "performer", name, element, index);
17754    if (element.hasFunction()) {
17755      composeCodeableConcept(t, "ProcedurePerformerComponent", "function", element.getFunction(), -1);
17756    }
17757    if (element.hasActor()) {
17758      composeReference(t, "ProcedurePerformerComponent", "actor", element.getActor(), -1);
17759    }
17760    if (element.hasOnBehalfOf()) {
17761      composeReference(t, "ProcedurePerformerComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
17762    }
17763  }
17764
17765  protected void composeProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent element, int index) {
17766    if (element == null) 
17767      return;
17768    Complex t;
17769    if (Utilities.noString(parentType))
17770      t = parent;
17771    else {
17772      t = parent.predicate("fhir:"+parentType+'.'+name);
17773    }
17774    composeBackboneElement(t, "focalDevice", name, element, index);
17775    if (element.hasAction()) {
17776      composeCodeableConcept(t, "ProcedureFocalDeviceComponent", "action", element.getAction(), -1);
17777    }
17778    if (element.hasManipulated()) {
17779      composeReference(t, "ProcedureFocalDeviceComponent", "manipulated", element.getManipulated(), -1);
17780    }
17781  }
17782
17783  protected void composeProvenance(Complex parent, String parentType, String name, Provenance element, int index) {
17784    if (element == null) 
17785      return;
17786    Complex t;
17787    if (Utilities.noString(parentType))
17788      t = parent;
17789    else {
17790      t = parent.predicate("fhir:"+parentType+'.'+name);
17791    }
17792    composeDomainResource(t, "Provenance", name, element, index);
17793    for (int i = 0; i < element.getTarget().size(); i++) {
17794      composeReference(t, "Provenance", "target", element.getTarget().get(i), i);
17795    }
17796    if (element.hasOccurred()) {
17797      composeType(t, "Provenance", "occurred", element.getOccurred(), -1);
17798    }
17799    if (element.hasRecordedElement()) {
17800      composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1);
17801    }
17802    for (int i = 0; i < element.getPolicy().size(); i++) {
17803      composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i);
17804    }
17805    if (element.hasLocation()) {
17806      composeReference(t, "Provenance", "location", element.getLocation(), -1);
17807    }
17808    for (int i = 0; i < element.getReason().size(); i++) {
17809      composeCodeableConcept(t, "Provenance", "reason", element.getReason().get(i), i);
17810    }
17811    if (element.hasActivity()) {
17812      composeCodeableConcept(t, "Provenance", "activity", element.getActivity(), -1);
17813    }
17814    for (int i = 0; i < element.getAgent().size(); i++) {
17815      composeProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i);
17816    }
17817    for (int i = 0; i < element.getEntity().size(); i++) {
17818      composeProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i);
17819    }
17820    for (int i = 0; i < element.getSignature().size(); i++) {
17821      composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i);
17822    }
17823  }
17824
17825  protected void composeProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent element, int index) {
17826    if (element == null) 
17827      return;
17828    Complex t;
17829    if (Utilities.noString(parentType))
17830      t = parent;
17831    else {
17832      t = parent.predicate("fhir:"+parentType+'.'+name);
17833    }
17834    composeBackboneElement(t, "agent", name, element, index);
17835    if (element.hasType()) {
17836      composeCodeableConcept(t, "ProvenanceAgentComponent", "type", element.getType(), -1);
17837    }
17838    for (int i = 0; i < element.getRole().size(); i++) {
17839      composeCodeableConcept(t, "ProvenanceAgentComponent", "role", element.getRole().get(i), i);
17840    }
17841    if (element.hasWho()) {
17842      composeReference(t, "ProvenanceAgentComponent", "who", element.getWho(), -1);
17843    }
17844    if (element.hasOnBehalfOf()) {
17845      composeReference(t, "ProvenanceAgentComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
17846    }
17847  }
17848
17849  protected void composeProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent element, int index) {
17850    if (element == null) 
17851      return;
17852    Complex t;
17853    if (Utilities.noString(parentType))
17854      t = parent;
17855    else {
17856      t = parent.predicate("fhir:"+parentType+'.'+name);
17857    }
17858    composeBackboneElement(t, "entity", name, element, index);
17859    if (element.hasRoleElement()) {
17860      composeEnum(t, "ProvenanceEntityComponent", "role", element.getRoleElement(), -1);
17861    }
17862    if (element.hasWhat()) {
17863      composeReference(t, "ProvenanceEntityComponent", "what", element.getWhat(), -1);
17864    }
17865    for (int i = 0; i < element.getAgent().size(); i++) {
17866      composeProvenanceAgentComponent(t, "ProvenanceEntityComponent", "agent", element.getAgent().get(i), i);
17867    }
17868  }
17869
17870  protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire element, int index) {
17871    if (element == null) 
17872      return;
17873    Complex t;
17874    if (Utilities.noString(parentType))
17875      t = parent;
17876    else {
17877      t = parent.predicate("fhir:"+parentType+'.'+name);
17878    }
17879    composeMetadataResource(t, "Questionnaire", name, element, index);
17880    if (element.hasUrlElement()) {
17881      composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1);
17882    }
17883    for (int i = 0; i < element.getIdentifier().size(); i++) {
17884      composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i);
17885    }
17886    if (element.hasVersionElement()) {
17887      composeString(t, "Questionnaire", "version", element.getVersionElement(), -1);
17888    }
17889    if (element.hasNameElement()) {
17890      composeString(t, "Questionnaire", "name", element.getNameElement(), -1);
17891    }
17892    if (element.hasTitleElement()) {
17893      composeString(t, "Questionnaire", "title", element.getTitleElement(), -1);
17894    }
17895    for (int i = 0; i < element.getDerivedFrom().size(); i++) {
17896      composeCanonical(t, "Questionnaire", "derivedFrom", element.getDerivedFrom().get(i), i);
17897    }
17898    if (element.hasStatusElement()) {
17899      composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1);
17900    }
17901    if (element.hasExperimentalElement()) {
17902      composeBoolean(t, "Questionnaire", "experimental", element.getExperimentalElement(), -1);
17903    }
17904    for (int i = 0; i < element.getSubjectType().size(); i++) {
17905      composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i);
17906    }
17907    if (element.hasDateElement()) {
17908      composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1);
17909    }
17910    if (element.hasPublisherElement()) {
17911      composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1);
17912    }
17913    for (int i = 0; i < element.getContact().size(); i++) {
17914      composeContactDetail(t, "Questionnaire", "contact", element.getContact().get(i), i);
17915    }
17916    if (element.hasDescriptionElement()) {
17917      composeMarkdown(t, "Questionnaire", "description", element.getDescriptionElement(), -1);
17918    }
17919    for (int i = 0; i < element.getUseContext().size(); i++) {
17920      composeUsageContext(t, "Questionnaire", "useContext", element.getUseContext().get(i), i);
17921    }
17922    for (int i = 0; i < element.getJurisdiction().size(); i++) {
17923      composeCodeableConcept(t, "Questionnaire", "jurisdiction", element.getJurisdiction().get(i), i);
17924    }
17925    if (element.hasPurposeElement()) {
17926      composeMarkdown(t, "Questionnaire", "purpose", element.getPurposeElement(), -1);
17927    }
17928    if (element.hasCopyrightElement()) {
17929      composeMarkdown(t, "Questionnaire", "copyright", element.getCopyrightElement(), -1);
17930    }
17931    if (element.hasApprovalDateElement()) {
17932      composeDate(t, "Questionnaire", "approvalDate", element.getApprovalDateElement(), -1);
17933    }
17934    if (element.hasLastReviewDateElement()) {
17935      composeDate(t, "Questionnaire", "lastReviewDate", element.getLastReviewDateElement(), -1);
17936    }
17937    if (element.hasEffectivePeriod()) {
17938      composePeriod(t, "Questionnaire", "effectivePeriod", element.getEffectivePeriod(), -1);
17939    }
17940    for (int i = 0; i < element.getCode().size(); i++) {
17941      composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i);
17942    }
17943    for (int i = 0; i < element.getItem().size(); i++) {
17944      composeQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i);
17945    }
17946  }
17947
17948  protected void composeQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent element, int index) {
17949    if (element == null) 
17950      return;
17951    Complex t;
17952    if (Utilities.noString(parentType))
17953      t = parent;
17954    else {
17955      t = parent.predicate("fhir:"+parentType+'.'+name);
17956    }
17957    composeBackboneElement(t, "item", name, element, index);
17958    if (element.hasLinkIdElement()) {
17959      composeString(t, "QuestionnaireItemComponent", "linkId", element.getLinkIdElement(), -1);
17960    }
17961    if (element.hasDefinitionElement()) {
17962      composeUri(t, "QuestionnaireItemComponent", "definition", element.getDefinitionElement(), -1);
17963    }
17964    for (int i = 0; i < element.getCode().size(); i++) {
17965      composeCoding(t, "QuestionnaireItemComponent", "code", element.getCode().get(i), i);
17966    }
17967    if (element.hasPrefixElement()) {
17968      composeString(t, "QuestionnaireItemComponent", "prefix", element.getPrefixElement(), -1);
17969    }
17970    if (element.hasTextElement()) {
17971      composeString(t, "QuestionnaireItemComponent", "text", element.getTextElement(), -1);
17972    }
17973    if (element.hasTypeElement()) {
17974      composeEnum(t, "QuestionnaireItemComponent", "type", element.getTypeElement(), -1);
17975    }
17976    for (int i = 0; i < element.getEnableWhen().size(); i++) {
17977      composeQuestionnaireItemEnableWhenComponent(t, "QuestionnaireItemComponent", "enableWhen", element.getEnableWhen().get(i), i);
17978    }
17979    if (element.hasEnableBehaviorElement()) {
17980      composeEnum(t, "QuestionnaireItemComponent", "enableBehavior", element.getEnableBehaviorElement(), -1);
17981    }
17982    if (element.hasRequiredElement()) {
17983      composeBoolean(t, "QuestionnaireItemComponent", "required", element.getRequiredElement(), -1);
17984    }
17985    if (element.hasRepeatsElement()) {
17986      composeBoolean(t, "QuestionnaireItemComponent", "repeats", element.getRepeatsElement(), -1);
17987    }
17988    if (element.hasReadOnlyElement()) {
17989      composeBoolean(t, "QuestionnaireItemComponent", "readOnly", element.getReadOnlyElement(), -1);
17990    }
17991    if (element.hasMaxLengthElement()) {
17992      composeInteger(t, "QuestionnaireItemComponent", "maxLength", element.getMaxLengthElement(), -1);
17993    }
17994    if (element.hasAnswerValueSetElement()) {
17995      composeCanonical(t, "QuestionnaireItemComponent", "answerValueSet", element.getAnswerValueSetElement(), -1);
17996    }
17997    for (int i = 0; i < element.getAnswerOption().size(); i++) {
17998      composeQuestionnaireItemAnswerOptionComponent(t, "QuestionnaireItemComponent", "answerOption", element.getAnswerOption().get(i), i);
17999    }
18000    for (int i = 0; i < element.getInitial().size(); i++) {
18001      composeQuestionnaireItemInitialComponent(t, "QuestionnaireItemComponent", "initial", element.getInitial().get(i), i);
18002    }
18003    for (int i = 0; i < element.getItem().size(); i++) {
18004      composeQuestionnaireItemComponent(t, "QuestionnaireItemComponent", "item", element.getItem().get(i), i);
18005    }
18006  }
18007
18008  protected void composeQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent element, int index) {
18009    if (element == null) 
18010      return;
18011    Complex t;
18012    if (Utilities.noString(parentType))
18013      t = parent;
18014    else {
18015      t = parent.predicate("fhir:"+parentType+'.'+name);
18016    }
18017    composeBackboneElement(t, "enableWhen", name, element, index);
18018    if (element.hasQuestionElement()) {
18019      composeString(t, "QuestionnaireItemEnableWhenComponent", "question", element.getQuestionElement(), -1);
18020    }
18021    if (element.hasOperatorElement()) {
18022      composeEnum(t, "QuestionnaireItemEnableWhenComponent", "operator", element.getOperatorElement(), -1);
18023    }
18024    if (element.hasAnswer()) {
18025      composeType(t, "QuestionnaireItemEnableWhenComponent", "answer", element.getAnswer(), -1);
18026    }
18027  }
18028
18029  protected void composeQuestionnaireItemAnswerOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemAnswerOptionComponent 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, "answerOption", name, element, index);
18039    if (element.hasValue()) {
18040      composeType(t, "QuestionnaireItemAnswerOptionComponent", "value", element.getValue(), -1);
18041    }
18042    if (element.hasInitialSelectedElement()) {
18043      composeBoolean(t, "QuestionnaireItemAnswerOptionComponent", "initialSelected", element.getInitialSelectedElement(), -1);
18044    }
18045  }
18046
18047  protected void composeQuestionnaireItemInitialComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemInitialComponent element, int index) {
18048    if (element == null) 
18049      return;
18050    Complex t;
18051    if (Utilities.noString(parentType))
18052      t = parent;
18053    else {
18054      t = parent.predicate("fhir:"+parentType+'.'+name);
18055    }
18056    composeBackboneElement(t, "initial", name, element, index);
18057    if (element.hasValue()) {
18058      composeType(t, "QuestionnaireItemInitialComponent", "value", element.getValue(), -1);
18059    }
18060  }
18061
18062  protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse element, int index) {
18063    if (element == null) 
18064      return;
18065    Complex t;
18066    if (Utilities.noString(parentType))
18067      t = parent;
18068    else {
18069      t = parent.predicate("fhir:"+parentType+'.'+name);
18070    }
18071    composeDomainResource(t, "QuestionnaireResponse", name, element, index);
18072    if (element.hasIdentifier()) {
18073      composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier(), -1);
18074    }
18075    for (int i = 0; i < element.getBasedOn().size(); i++) {
18076      composeReference(t, "QuestionnaireResponse", "basedOn", element.getBasedOn().get(i), i);
18077    }
18078    for (int i = 0; i < element.getPartOf().size(); i++) {
18079      composeReference(t, "QuestionnaireResponse", "partOf", element.getPartOf().get(i), i);
18080    }
18081    if (element.hasQuestionnaireElement()) {
18082      composeCanonical(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaireElement(), -1);
18083    }
18084    if (element.hasStatusElement()) {
18085      composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1);
18086    }
18087    if (element.hasSubject()) {
18088      composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1);
18089    }
18090    if (element.hasEncounter()) {
18091      composeReference(t, "QuestionnaireResponse", "encounter", element.getEncounter(), -1);
18092    }
18093    if (element.hasAuthoredElement()) {
18094      composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1);
18095    }
18096    if (element.hasAuthor()) {
18097      composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1);
18098    }
18099    if (element.hasSource()) {
18100      composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1);
18101    }
18102    for (int i = 0; i < element.getItem().size(); i++) {
18103      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i);
18104    }
18105  }
18106
18107  protected void composeQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element, int index) {
18108    if (element == null) 
18109      return;
18110    Complex t;
18111    if (Utilities.noString(parentType))
18112      t = parent;
18113    else {
18114      t = parent.predicate("fhir:"+parentType+'.'+name);
18115    }
18116    composeBackboneElement(t, "item", name, element, index);
18117    if (element.hasLinkIdElement()) {
18118      composeString(t, "QuestionnaireResponseItemComponent", "linkId", element.getLinkIdElement(), -1);
18119    }
18120    if (element.hasDefinitionElement()) {
18121      composeUri(t, "QuestionnaireResponseItemComponent", "definition", element.getDefinitionElement(), -1);
18122    }
18123    if (element.hasTextElement()) {
18124      composeString(t, "QuestionnaireResponseItemComponent", "text", element.getTextElement(), -1);
18125    }
18126    for (int i = 0; i < element.getAnswer().size(); i++) {
18127      composeQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponseItemComponent", "answer", element.getAnswer().get(i), i);
18128    }
18129    for (int i = 0; i < element.getItem().size(); i++) {
18130      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemComponent", "item", element.getItem().get(i), i);
18131    }
18132  }
18133
18134  protected void composeQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element, int index) {
18135    if (element == null) 
18136      return;
18137    Complex t;
18138    if (Utilities.noString(parentType))
18139      t = parent;
18140    else {
18141      t = parent.predicate("fhir:"+parentType+'.'+name);
18142    }
18143    composeBackboneElement(t, "answer", name, element, index);
18144    if (element.hasValue()) {
18145      composeType(t, "QuestionnaireResponseItemAnswerComponent", "value", element.getValue(), -1);
18146    }
18147    for (int i = 0; i < element.getItem().size(); i++) {
18148      composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemAnswerComponent", "item", element.getItem().get(i), i);
18149    }
18150  }
18151
18152  protected void composeRegulatedAuthorization(Complex parent, String parentType, String name, RegulatedAuthorization element, int index) {
18153    if (element == null) 
18154      return;
18155    Complex t;
18156    if (Utilities.noString(parentType))
18157      t = parent;
18158    else {
18159      t = parent.predicate("fhir:"+parentType+'.'+name);
18160    }
18161    composeDomainResource(t, "RegulatedAuthorization", name, element, index);
18162    for (int i = 0; i < element.getIdentifier().size(); i++) {
18163      composeIdentifier(t, "RegulatedAuthorization", "identifier", element.getIdentifier().get(i), i);
18164    }
18165    if (element.hasSubject()) {
18166      composeReference(t, "RegulatedAuthorization", "subject", element.getSubject(), -1);
18167    }
18168    if (element.hasType()) {
18169      composeCodeableConcept(t, "RegulatedAuthorization", "type", element.getType(), -1);
18170    }
18171    if (element.hasDescriptionElement()) {
18172      composeMarkdown(t, "RegulatedAuthorization", "description", element.getDescriptionElement(), -1);
18173    }
18174    for (int i = 0; i < element.getRegion().size(); i++) {
18175      composeCodeableConcept(t, "RegulatedAuthorization", "region", element.getRegion().get(i), i);
18176    }
18177    if (element.hasStatus()) {
18178      composeCodeableConcept(t, "RegulatedAuthorization", "status", element.getStatus(), -1);
18179    }
18180    if (element.hasStatusDateElement()) {
18181      composeDateTime(t, "RegulatedAuthorization", "statusDate", element.getStatusDateElement(), -1);
18182    }
18183    if (element.hasValidityPeriod()) {
18184      composePeriod(t, "RegulatedAuthorization", "validityPeriod", element.getValidityPeriod(), -1);
18185    }
18186    for (int i = 0; i < element.getBasis().size(); i++) {
18187      composeCodeableConcept(t, "RegulatedAuthorization", "basis", element.getBasis().get(i), i);
18188    }
18189    for (int i = 0; i < element.getRelatedDate().size(); i++) {
18190      composeRegulatedAuthorizationRelatedDateComponent(t, "RegulatedAuthorization", "relatedDate", element.getRelatedDate().get(i), i);
18191    }
18192    for (int i = 0; i < element.getJurisdictionalAuthorization().size(); i++) {
18193      composeReference(t, "RegulatedAuthorization", "jurisdictionalAuthorization", element.getJurisdictionalAuthorization().get(i), i);
18194    }
18195    if (element.hasHolder()) {
18196      composeReference(t, "RegulatedAuthorization", "holder", element.getHolder(), -1);
18197    }
18198    if (element.hasRegulator()) {
18199      composeReference(t, "RegulatedAuthorization", "regulator", element.getRegulator(), -1);
18200    }
18201    if (element.hasCase()) {
18202      composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorization", "case", element.getCase(), -1);
18203    }
18204  }
18205
18206  protected void composeRegulatedAuthorizationRelatedDateComponent(Complex parent, String parentType, String name, RegulatedAuthorization.RegulatedAuthorizationRelatedDateComponent element, int index) {
18207    if (element == null) 
18208      return;
18209    Complex t;
18210    if (Utilities.noString(parentType))
18211      t = parent;
18212    else {
18213      t = parent.predicate("fhir:"+parentType+'.'+name);
18214    }
18215    composeBackboneElement(t, "relatedDate", name, element, index);
18216    if (element.hasDate()) {
18217      composeType(t, "RegulatedAuthorizationRelatedDateComponent", "date", element.getDate(), -1);
18218    }
18219    if (element.hasType()) {
18220      composeCodeableConcept(t, "RegulatedAuthorizationRelatedDateComponent", "type", element.getType(), -1);
18221    }
18222  }
18223
18224  protected void composeRegulatedAuthorizationCaseComponent(Complex parent, String parentType, String name, RegulatedAuthorization.RegulatedAuthorizationCaseComponent element, int index) {
18225    if (element == null) 
18226      return;
18227    Complex t;
18228    if (Utilities.noString(parentType))
18229      t = parent;
18230    else {
18231      t = parent.predicate("fhir:"+parentType+'.'+name);
18232    }
18233    composeBackboneElement(t, "case", name, element, index);
18234    if (element.hasIdentifier()) {
18235      composeIdentifier(t, "RegulatedAuthorizationCaseComponent", "identifier", element.getIdentifier(), -1);
18236    }
18237    if (element.hasType()) {
18238      composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "type", element.getType(), -1);
18239    }
18240    if (element.hasStatus()) {
18241      composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "status", element.getStatus(), -1);
18242    }
18243    if (element.hasDate()) {
18244      composeType(t, "RegulatedAuthorizationCaseComponent", "date", element.getDate(), -1);
18245    }
18246    for (int i = 0; i < element.getApplication().size(); i++) {
18247      composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorizationCaseComponent", "application", element.getApplication().get(i), i);
18248    }
18249  }
18250
18251  protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson element, int index) {
18252    if (element == null) 
18253      return;
18254    Complex t;
18255    if (Utilities.noString(parentType))
18256      t = parent;
18257    else {
18258      t = parent.predicate("fhir:"+parentType+'.'+name);
18259    }
18260    composeDomainResource(t, "RelatedPerson", name, element, index);
18261    for (int i = 0; i < element.getIdentifier().size(); i++) {
18262      composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i);
18263    }
18264    if (element.hasActiveElement()) {
18265      composeBoolean(t, "RelatedPerson", "active", element.getActiveElement(), -1);
18266    }
18267    if (element.hasPatient()) {
18268      composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1);
18269    }
18270    for (int i = 0; i < element.getRelationship().size(); i++) {
18271      composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship().get(i), i);
18272    }
18273    for (int i = 0; i < element.getName().size(); i++) {
18274      composeHumanName(t, "RelatedPerson", "name", element.getName().get(i), i);
18275    }
18276    for (int i = 0; i < element.getTelecom().size(); i++) {
18277      composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i);
18278    }
18279    if (element.hasGenderElement()) {
18280      composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1);
18281    }
18282    if (element.hasBirthDateElement()) {
18283      composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1);
18284    }
18285    for (int i = 0; i < element.getAddress().size(); i++) {
18286      composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i);
18287    }
18288    for (int i = 0; i < element.getPhoto().size(); i++) {
18289      composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i);
18290    }
18291    if (element.hasPeriod()) {
18292      composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1);
18293    }
18294    for (int i = 0; i < element.getCommunication().size(); i++) {
18295      composeRelatedPersonCommunicationComponent(t, "RelatedPerson", "communication", element.getCommunication().get(i), i);
18296    }
18297  }
18298
18299  protected void composeRelatedPersonCommunicationComponent(Complex parent, String parentType, String name, RelatedPerson.RelatedPersonCommunicationComponent element, int index) {
18300    if (element == null) 
18301      return;
18302    Complex t;
18303    if (Utilities.noString(parentType))
18304      t = parent;
18305    else {
18306      t = parent.predicate("fhir:"+parentType+'.'+name);
18307    }
18308    composeBackboneElement(t, "communication", name, element, index);
18309    if (element.hasLanguage()) {
18310      composeCodeableConcept(t, "RelatedPersonCommunicationComponent", "language", element.getLanguage(), -1);
18311    }
18312    if (element.hasPreferredElement()) {
18313      composeBoolean(t, "RelatedPersonCommunicationComponent", "preferred", element.getPreferredElement(), -1);
18314    }
18315  }
18316
18317  protected void composeRequestGroup(Complex parent, String parentType, String name, RequestGroup element, int index) {
18318    if (element == null) 
18319      return;
18320    Complex t;
18321    if (Utilities.noString(parentType))
18322      t = parent;
18323    else {
18324      t = parent.predicate("fhir:"+parentType+'.'+name);
18325    }
18326    composeDomainResource(t, "RequestGroup", name, element, index);
18327    for (int i = 0; i < element.getIdentifier().size(); i++) {
18328      composeIdentifier(t, "RequestGroup", "identifier", element.getIdentifier().get(i), i);
18329    }
18330    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
18331      composeCanonical(t, "RequestGroup", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
18332    }
18333    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
18334      composeUri(t, "RequestGroup", "instantiatesUri", element.getInstantiatesUri().get(i), i);
18335    }
18336    for (int i = 0; i < element.getBasedOn().size(); i++) {
18337      composeReference(t, "RequestGroup", "basedOn", element.getBasedOn().get(i), i);
18338    }
18339    for (int i = 0; i < element.getReplaces().size(); i++) {
18340      composeReference(t, "RequestGroup", "replaces", element.getReplaces().get(i), i);
18341    }
18342    if (element.hasGroupIdentifier()) {
18343      composeIdentifier(t, "RequestGroup", "groupIdentifier", element.getGroupIdentifier(), -1);
18344    }
18345    if (element.hasStatusElement()) {
18346      composeEnum(t, "RequestGroup", "status", element.getStatusElement(), -1);
18347    }
18348    if (element.hasIntentElement()) {
18349      composeEnum(t, "RequestGroup", "intent", element.getIntentElement(), -1);
18350    }
18351    if (element.hasPriorityElement()) {
18352      composeEnum(t, "RequestGroup", "priority", element.getPriorityElement(), -1);
18353    }
18354    if (element.hasCode()) {
18355      composeCodeableConcept(t, "RequestGroup", "code", element.getCode(), -1);
18356    }
18357    if (element.hasSubject()) {
18358      composeReference(t, "RequestGroup", "subject", element.getSubject(), -1);
18359    }
18360    if (element.hasEncounter()) {
18361      composeReference(t, "RequestGroup", "encounter", element.getEncounter(), -1);
18362    }
18363    if (element.hasAuthoredOnElement()) {
18364      composeDateTime(t, "RequestGroup", "authoredOn", element.getAuthoredOnElement(), -1);
18365    }
18366    if (element.hasAuthor()) {
18367      composeReference(t, "RequestGroup", "author", element.getAuthor(), -1);
18368    }
18369    for (int i = 0; i < element.getReason().size(); i++) {
18370      composeCodeableReference(t, "RequestGroup", "reason", element.getReason().get(i), i);
18371    }
18372    for (int i = 0; i < element.getNote().size(); i++) {
18373      composeAnnotation(t, "RequestGroup", "note", element.getNote().get(i), i);
18374    }
18375    for (int i = 0; i < element.getAction().size(); i++) {
18376      composeRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i);
18377    }
18378  }
18379
18380  protected void composeRequestGroupActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionComponent element, int index) {
18381    if (element == null) 
18382      return;
18383    Complex t;
18384    if (Utilities.noString(parentType))
18385      t = parent;
18386    else {
18387      t = parent.predicate("fhir:"+parentType+'.'+name);
18388    }
18389    composeBackboneElement(t, "action", name, element, index);
18390    if (element.hasPrefixElement()) {
18391      composeString(t, "RequestGroupActionComponent", "prefix", element.getPrefixElement(), -1);
18392    }
18393    if (element.hasTitleElement()) {
18394      composeString(t, "RequestGroupActionComponent", "title", element.getTitleElement(), -1);
18395    }
18396    if (element.hasDescriptionElement()) {
18397      composeString(t, "RequestGroupActionComponent", "description", element.getDescriptionElement(), -1);
18398    }
18399    if (element.hasTextEquivalentElement()) {
18400      composeString(t, "RequestGroupActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1);
18401    }
18402    if (element.hasPriorityElement()) {
18403      composeEnum(t, "RequestGroupActionComponent", "priority", element.getPriorityElement(), -1);
18404    }
18405    for (int i = 0; i < element.getCode().size(); i++) {
18406      composeCodeableConcept(t, "RequestGroupActionComponent", "code", element.getCode().get(i), i);
18407    }
18408    for (int i = 0; i < element.getDocumentation().size(); i++) {
18409      composeRelatedArtifact(t, "RequestGroupActionComponent", "documentation", element.getDocumentation().get(i), i);
18410    }
18411    for (int i = 0; i < element.getCondition().size(); i++) {
18412      composeRequestGroupActionConditionComponent(t, "RequestGroupActionComponent", "condition", element.getCondition().get(i), i);
18413    }
18414    for (int i = 0; i < element.getRelatedAction().size(); i++) {
18415      composeRequestGroupActionRelatedActionComponent(t, "RequestGroupActionComponent", "relatedAction", element.getRelatedAction().get(i), i);
18416    }
18417    if (element.hasTiming()) {
18418      composeType(t, "RequestGroupActionComponent", "timing", element.getTiming(), -1);
18419    }
18420    for (int i = 0; i < element.getParticipant().size(); i++) {
18421      composeReference(t, "RequestGroupActionComponent", "participant", element.getParticipant().get(i), i);
18422    }
18423    if (element.hasType()) {
18424      composeCodeableConcept(t, "RequestGroupActionComponent", "type", element.getType(), -1);
18425    }
18426    if (element.hasGroupingBehaviorElement()) {
18427      composeEnum(t, "RequestGroupActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1);
18428    }
18429    if (element.hasSelectionBehaviorElement()) {
18430      composeEnum(t, "RequestGroupActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1);
18431    }
18432    if (element.hasRequiredBehaviorElement()) {
18433      composeEnum(t, "RequestGroupActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1);
18434    }
18435    if (element.hasPrecheckBehaviorElement()) {
18436      composeEnum(t, "RequestGroupActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1);
18437    }
18438    if (element.hasCardinalityBehaviorElement()) {
18439      composeEnum(t, "RequestGroupActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1);
18440    }
18441    if (element.hasResource()) {
18442      composeReference(t, "RequestGroupActionComponent", "resource", element.getResource(), -1);
18443    }
18444    for (int i = 0; i < element.getAction().size(); i++) {
18445      composeRequestGroupActionComponent(t, "RequestGroupActionComponent", "action", element.getAction().get(i), i);
18446    }
18447  }
18448
18449  protected void composeRequestGroupActionConditionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionConditionComponent element, int index) {
18450    if (element == null) 
18451      return;
18452    Complex t;
18453    if (Utilities.noString(parentType))
18454      t = parent;
18455    else {
18456      t = parent.predicate("fhir:"+parentType+'.'+name);
18457    }
18458    composeBackboneElement(t, "condition", name, element, index);
18459    if (element.hasKindElement()) {
18460      composeEnum(t, "RequestGroupActionConditionComponent", "kind", element.getKindElement(), -1);
18461    }
18462    if (element.hasExpression()) {
18463      composeExpression(t, "RequestGroupActionConditionComponent", "expression", element.getExpression(), -1);
18464    }
18465  }
18466
18467  protected void composeRequestGroupActionRelatedActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionRelatedActionComponent element, int index) {
18468    if (element == null) 
18469      return;
18470    Complex t;
18471    if (Utilities.noString(parentType))
18472      t = parent;
18473    else {
18474      t = parent.predicate("fhir:"+parentType+'.'+name);
18475    }
18476    composeBackboneElement(t, "relatedAction", name, element, index);
18477    if (element.hasActionIdElement()) {
18478      composeId(t, "RequestGroupActionRelatedActionComponent", "actionId", element.getActionIdElement(), -1);
18479    }
18480    if (element.hasRelationshipElement()) {
18481      composeEnum(t, "RequestGroupActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1);
18482    }
18483    if (element.hasOffset()) {
18484      composeType(t, "RequestGroupActionRelatedActionComponent", "offset", element.getOffset(), -1);
18485    }
18486  }
18487
18488  protected void composeResearchStudy(Complex parent, String parentType, String name, ResearchStudy element, int index) {
18489    if (element == null) 
18490      return;
18491    Complex t;
18492    if (Utilities.noString(parentType))
18493      t = parent;
18494    else {
18495      t = parent.predicate("fhir:"+parentType+'.'+name);
18496    }
18497    composeDomainResource(t, "ResearchStudy", name, element, index);
18498    for (int i = 0; i < element.getIdentifier().size(); i++) {
18499      composeIdentifier(t, "ResearchStudy", "identifier", element.getIdentifier().get(i), i);
18500    }
18501    if (element.hasTitleElement()) {
18502      composeString(t, "ResearchStudy", "title", element.getTitleElement(), -1);
18503    }
18504    for (int i = 0; i < element.getProtocol().size(); i++) {
18505      composeReference(t, "ResearchStudy", "protocol", element.getProtocol().get(i), i);
18506    }
18507    for (int i = 0; i < element.getPartOf().size(); i++) {
18508      composeReference(t, "ResearchStudy", "partOf", element.getPartOf().get(i), i);
18509    }
18510    if (element.hasStatusElement()) {
18511      composeEnum(t, "ResearchStudy", "status", element.getStatusElement(), -1);
18512    }
18513    if (element.hasPrimaryPurposeType()) {
18514      composeCodeableConcept(t, "ResearchStudy", "primaryPurposeType", element.getPrimaryPurposeType(), -1);
18515    }
18516    if (element.hasPhase()) {
18517      composeCodeableConcept(t, "ResearchStudy", "phase", element.getPhase(), -1);
18518    }
18519    for (int i = 0; i < element.getCategory().size(); i++) {
18520      composeCodeableConcept(t, "ResearchStudy", "category", element.getCategory().get(i), i);
18521    }
18522    for (int i = 0; i < element.getFocus().size(); i++) {
18523      composeCodeableConcept(t, "ResearchStudy", "focus", element.getFocus().get(i), i);
18524    }
18525    for (int i = 0; i < element.getCondition().size(); i++) {
18526      composeCodeableConcept(t, "ResearchStudy", "condition", element.getCondition().get(i), i);
18527    }
18528    for (int i = 0; i < element.getContact().size(); i++) {
18529      composeContactDetail(t, "ResearchStudy", "contact", element.getContact().get(i), i);
18530    }
18531    for (int i = 0; i < element.getRelatedArtifact().size(); i++) {
18532      composeRelatedArtifact(t, "ResearchStudy", "relatedArtifact", element.getRelatedArtifact().get(i), i);
18533    }
18534    for (int i = 0; i < element.getKeyword().size(); i++) {
18535      composeCodeableConcept(t, "ResearchStudy", "keyword", element.getKeyword().get(i), i);
18536    }
18537    for (int i = 0; i < element.getLocation().size(); i++) {
18538      composeCodeableConcept(t, "ResearchStudy", "location", element.getLocation().get(i), i);
18539    }
18540    if (element.hasDescriptionElement()) {
18541      composeMarkdown(t, "ResearchStudy", "description", element.getDescriptionElement(), -1);
18542    }
18543    for (int i = 0; i < element.getEnrollment().size(); i++) {
18544      composeReference(t, "ResearchStudy", "enrollment", element.getEnrollment().get(i), i);
18545    }
18546    if (element.hasPeriod()) {
18547      composePeriod(t, "ResearchStudy", "period", element.getPeriod(), -1);
18548    }
18549    if (element.hasSponsor()) {
18550      composeReference(t, "ResearchStudy", "sponsor", element.getSponsor(), -1);
18551    }
18552    if (element.hasPrincipalInvestigator()) {
18553      composeReference(t, "ResearchStudy", "principalInvestigator", element.getPrincipalInvestigator(), -1);
18554    }
18555    for (int i = 0; i < element.getSite().size(); i++) {
18556      composeReference(t, "ResearchStudy", "site", element.getSite().get(i), i);
18557    }
18558    if (element.hasReasonStopped()) {
18559      composeCodeableConcept(t, "ResearchStudy", "reasonStopped", element.getReasonStopped(), -1);
18560    }
18561    for (int i = 0; i < element.getNote().size(); i++) {
18562      composeAnnotation(t, "ResearchStudy", "note", element.getNote().get(i), i);
18563    }
18564    for (int i = 0; i < element.getArm().size(); i++) {
18565      composeResearchStudyArmComponent(t, "ResearchStudy", "arm", element.getArm().get(i), i);
18566    }
18567    for (int i = 0; i < element.getObjective().size(); i++) {
18568      composeResearchStudyObjectiveComponent(t, "ResearchStudy", "objective", element.getObjective().get(i), i);
18569    }
18570  }
18571
18572  protected void composeResearchStudyArmComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyArmComponent element, int index) {
18573    if (element == null) 
18574      return;
18575    Complex t;
18576    if (Utilities.noString(parentType))
18577      t = parent;
18578    else {
18579      t = parent.predicate("fhir:"+parentType+'.'+name);
18580    }
18581    composeBackboneElement(t, "arm", name, element, index);
18582    if (element.hasNameElement()) {
18583      composeString(t, "ResearchStudyArmComponent", "name", element.getNameElement(), -1);
18584    }
18585    if (element.hasType()) {
18586      composeCodeableConcept(t, "ResearchStudyArmComponent", "type", element.getType(), -1);
18587    }
18588    if (element.hasDescriptionElement()) {
18589      composeString(t, "ResearchStudyArmComponent", "description", element.getDescriptionElement(), -1);
18590    }
18591  }
18592
18593  protected void composeResearchStudyObjectiveComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyObjectiveComponent element, int index) {
18594    if (element == null) 
18595      return;
18596    Complex t;
18597    if (Utilities.noString(parentType))
18598      t = parent;
18599    else {
18600      t = parent.predicate("fhir:"+parentType+'.'+name);
18601    }
18602    composeBackboneElement(t, "objective", name, element, index);
18603    if (element.hasNameElement()) {
18604      composeString(t, "ResearchStudyObjectiveComponent", "name", element.getNameElement(), -1);
18605    }
18606    if (element.hasType()) {
18607      composeCodeableConcept(t, "ResearchStudyObjectiveComponent", "type", element.getType(), -1);
18608    }
18609  }
18610
18611  protected void composeResearchSubject(Complex parent, String parentType, String name, ResearchSubject element, int index) {
18612    if (element == null) 
18613      return;
18614    Complex t;
18615    if (Utilities.noString(parentType))
18616      t = parent;
18617    else {
18618      t = parent.predicate("fhir:"+parentType+'.'+name);
18619    }
18620    composeDomainResource(t, "ResearchSubject", name, element, index);
18621    for (int i = 0; i < element.getIdentifier().size(); i++) {
18622      composeIdentifier(t, "ResearchSubject", "identifier", element.getIdentifier().get(i), i);
18623    }
18624    if (element.hasStatusElement()) {
18625      composeEnum(t, "ResearchSubject", "status", element.getStatusElement(), -1);
18626    }
18627    for (int i = 0; i < element.getProgress().size(); i++) {
18628      composeResearchSubjectProgressComponent(t, "ResearchSubject", "progress", element.getProgress().get(i), i);
18629    }
18630    if (element.hasPeriod()) {
18631      composePeriod(t, "ResearchSubject", "period", element.getPeriod(), -1);
18632    }
18633    if (element.hasStudy()) {
18634      composeReference(t, "ResearchSubject", "study", element.getStudy(), -1);
18635    }
18636    if (element.hasIndividual()) {
18637      composeReference(t, "ResearchSubject", "individual", element.getIndividual(), -1);
18638    }
18639    if (element.hasAssignedArmElement()) {
18640      composeString(t, "ResearchSubject", "assignedArm", element.getAssignedArmElement(), -1);
18641    }
18642    if (element.hasActualArmElement()) {
18643      composeString(t, "ResearchSubject", "actualArm", element.getActualArmElement(), -1);
18644    }
18645    if (element.hasConsent()) {
18646      composeReference(t, "ResearchSubject", "consent", element.getConsent(), -1);
18647    }
18648  }
18649
18650  protected void composeResearchSubjectProgressComponent(Complex parent, String parentType, String name, ResearchSubject.ResearchSubjectProgressComponent element, int index) {
18651    if (element == null) 
18652      return;
18653    Complex t;
18654    if (Utilities.noString(parentType))
18655      t = parent;
18656    else {
18657      t = parent.predicate("fhir:"+parentType+'.'+name);
18658    }
18659    composeBackboneElement(t, "progress", name, element, index);
18660    if (element.hasType()) {
18661      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "type", element.getType(), -1);
18662    }
18663    if (element.hasState()) {
18664      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "state", element.getState(), -1);
18665    }
18666    if (element.hasMilestone()) {
18667      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "milestone", element.getMilestone(), -1);
18668    }
18669    if (element.hasReason()) {
18670      composeCodeableConcept(t, "ResearchSubjectProgressComponent", "reason", element.getReason(), -1);
18671    }
18672    if (element.hasStartDateElement()) {
18673      composeDateTime(t, "ResearchSubjectProgressComponent", "startDate", element.getStartDateElement(), -1);
18674    }
18675  }
18676
18677  protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment element, int index) {
18678    if (element == null) 
18679      return;
18680    Complex t;
18681    if (Utilities.noString(parentType))
18682      t = parent;
18683    else {
18684      t = parent.predicate("fhir:"+parentType+'.'+name);
18685    }
18686    composeDomainResource(t, "RiskAssessment", name, element, index);
18687    for (int i = 0; i < element.getIdentifier().size(); i++) {
18688      composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier().get(i), i);
18689    }
18690    if (element.hasBasedOn()) {
18691      composeReference(t, "RiskAssessment", "basedOn", element.getBasedOn(), -1);
18692    }
18693    if (element.hasParent()) {
18694      composeReference(t, "RiskAssessment", "parent", element.getParent(), -1);
18695    }
18696    if (element.hasStatusElement()) {
18697      composeEnum(t, "RiskAssessment", "status", element.getStatusElement(), -1);
18698    }
18699    if (element.hasMethod()) {
18700      composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1);
18701    }
18702    if (element.hasCode()) {
18703      composeCodeableConcept(t, "RiskAssessment", "code", element.getCode(), -1);
18704    }
18705    if (element.hasSubject()) {
18706      composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1);
18707    }
18708    if (element.hasEncounter()) {
18709      composeReference(t, "RiskAssessment", "encounter", element.getEncounter(), -1);
18710    }
18711    if (element.hasOccurrence()) {
18712      composeType(t, "RiskAssessment", "occurrence", element.getOccurrence(), -1);
18713    }
18714    if (element.hasCondition()) {
18715      composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1);
18716    }
18717    if (element.hasPerformer()) {
18718      composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1);
18719    }
18720    for (int i = 0; i < element.getReason().size(); i++) {
18721      composeCodeableReference(t, "RiskAssessment", "reason", element.getReason().get(i), i);
18722    }
18723    for (int i = 0; i < element.getBasis().size(); i++) {
18724      composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i);
18725    }
18726    for (int i = 0; i < element.getPrediction().size(); i++) {
18727      composeRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i);
18728    }
18729    if (element.hasMitigationElement()) {
18730      composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1);
18731    }
18732    for (int i = 0; i < element.getNote().size(); i++) {
18733      composeAnnotation(t, "RiskAssessment", "note", element.getNote().get(i), i);
18734    }
18735  }
18736
18737  protected void composeRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent element, int index) {
18738    if (element == null) 
18739      return;
18740    Complex t;
18741    if (Utilities.noString(parentType))
18742      t = parent;
18743    else {
18744      t = parent.predicate("fhir:"+parentType+'.'+name);
18745    }
18746    composeBackboneElement(t, "prediction", name, element, index);
18747    if (element.hasOutcome()) {
18748      composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "outcome", element.getOutcome(), -1);
18749    }
18750    if (element.hasProbability()) {
18751      composeType(t, "RiskAssessmentPredictionComponent", "probability", element.getProbability(), -1);
18752    }
18753    if (element.hasQualitativeRisk()) {
18754      composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "qualitativeRisk", element.getQualitativeRisk(), -1);
18755    }
18756    if (element.hasRelativeRiskElement()) {
18757      composeDecimal(t, "RiskAssessmentPredictionComponent", "relativeRisk", element.getRelativeRiskElement(), -1);
18758    }
18759    if (element.hasWhen()) {
18760      composeType(t, "RiskAssessmentPredictionComponent", "when", element.getWhen(), -1);
18761    }
18762    if (element.hasRationaleElement()) {
18763      composeString(t, "RiskAssessmentPredictionComponent", "rationale", element.getRationaleElement(), -1);
18764    }
18765  }
18766
18767  protected void composeSchedule(Complex parent, String parentType, String name, Schedule 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, "Schedule", name, element, index);
18777    for (int i = 0; i < element.getIdentifier().size(); i++) {
18778      composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i);
18779    }
18780    if (element.hasActiveElement()) {
18781      composeBoolean(t, "Schedule", "active", element.getActiveElement(), -1);
18782    }
18783    for (int i = 0; i < element.getServiceCategory().size(); i++) {
18784      composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory().get(i), i);
18785    }
18786    for (int i = 0; i < element.getServiceType().size(); i++) {
18787      composeCodeableConcept(t, "Schedule", "serviceType", element.getServiceType().get(i), i);
18788    }
18789    for (int i = 0; i < element.getSpecialty().size(); i++) {
18790      composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i);
18791    }
18792    for (int i = 0; i < element.getActor().size(); i++) {
18793      composeReference(t, "Schedule", "actor", element.getActor().get(i), i);
18794    }
18795    if (element.hasPlanningHorizon()) {
18796      composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1);
18797    }
18798    if (element.hasCommentElement()) {
18799      composeString(t, "Schedule", "comment", element.getCommentElement(), -1);
18800    }
18801  }
18802
18803  protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter element, int index) {
18804    if (element == null) 
18805      return;
18806    Complex t;
18807    if (Utilities.noString(parentType))
18808      t = parent;
18809    else {
18810      t = parent.predicate("fhir:"+parentType+'.'+name);
18811    }
18812    composeCanonicalResource(t, "SearchParameter", name, element, index);
18813    if (element.hasUrlElement()) {
18814      composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1);
18815    }
18816    if (element.hasVersionElement()) {
18817      composeString(t, "SearchParameter", "version", element.getVersionElement(), -1);
18818    }
18819    if (element.hasNameElement()) {
18820      composeString(t, "SearchParameter", "name", element.getNameElement(), -1);
18821    }
18822    if (element.hasDerivedFromElement()) {
18823      composeCanonical(t, "SearchParameter", "derivedFrom", element.getDerivedFromElement(), -1);
18824    }
18825    if (element.hasStatusElement()) {
18826      composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1);
18827    }
18828    if (element.hasExperimentalElement()) {
18829      composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1);
18830    }
18831    if (element.hasDateElement()) {
18832      composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1);
18833    }
18834    if (element.hasPublisherElement()) {
18835      composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1);
18836    }
18837    for (int i = 0; i < element.getContact().size(); i++) {
18838      composeContactDetail(t, "SearchParameter", "contact", element.getContact().get(i), i);
18839    }
18840    if (element.hasDescriptionElement()) {
18841      composeMarkdown(t, "SearchParameter", "description", element.getDescriptionElement(), -1);
18842    }
18843    for (int i = 0; i < element.getUseContext().size(); i++) {
18844      composeUsageContext(t, "SearchParameter", "useContext", element.getUseContext().get(i), i);
18845    }
18846    for (int i = 0; i < element.getJurisdiction().size(); i++) {
18847      composeCodeableConcept(t, "SearchParameter", "jurisdiction", element.getJurisdiction().get(i), i);
18848    }
18849    if (element.hasPurposeElement()) {
18850      composeMarkdown(t, "SearchParameter", "purpose", element.getPurposeElement(), -1);
18851    }
18852    if (element.hasCodeElement()) {
18853      composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1);
18854    }
18855    for (int i = 0; i < element.getBase().size(); i++) {
18856      composeCode(t, "SearchParameter", "base", element.getBase().get(i), i);
18857    }
18858    if (element.hasTypeElement()) {
18859      composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1);
18860    }
18861    if (element.hasExpressionElement()) {
18862      composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1);
18863    }
18864    if (element.hasXpathElement()) {
18865      composeString(t, "SearchParameter", "xpath", element.getXpathElement(), -1);
18866    }
18867    if (element.hasXpathUsageElement()) {
18868      composeEnum(t, "SearchParameter", "xpathUsage", element.getXpathUsageElement(), -1);
18869    }
18870    for (int i = 0; i < element.getTarget().size(); i++) {
18871      composeCode(t, "SearchParameter", "target", element.getTarget().get(i), i);
18872    }
18873    if (element.hasMultipleOrElement()) {
18874      composeBoolean(t, "SearchParameter", "multipleOr", element.getMultipleOrElement(), -1);
18875    }
18876    if (element.hasMultipleAndElement()) {
18877      composeBoolean(t, "SearchParameter", "multipleAnd", element.getMultipleAndElement(), -1);
18878    }
18879    for (int i = 0; i < element.getComparator().size(); i++) {
18880      composeEnum(t, "SearchParameter", "comparator", element.getComparator().get(i), i);
18881    }
18882    for (int i = 0; i < element.getModifier().size(); i++) {
18883      composeEnum(t, "SearchParameter", "modifier", element.getModifier().get(i), i);
18884    }
18885    for (int i = 0; i < element.getChain().size(); i++) {
18886      composeString(t, "SearchParameter", "chain", element.getChain().get(i), i);
18887    }
18888    for (int i = 0; i < element.getComponent().size(); i++) {
18889      composeSearchParameterComponentComponent(t, "SearchParameter", "component", element.getComponent().get(i), i);
18890    }
18891  }
18892
18893  protected void composeSearchParameterComponentComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterComponentComponent element, int index) {
18894    if (element == null) 
18895      return;
18896    Complex t;
18897    if (Utilities.noString(parentType))
18898      t = parent;
18899    else {
18900      t = parent.predicate("fhir:"+parentType+'.'+name);
18901    }
18902    composeBackboneElement(t, "component", name, element, index);
18903    if (element.hasDefinitionElement()) {
18904      composeCanonical(t, "SearchParameterComponentComponent", "definition", element.getDefinitionElement(), -1);
18905    }
18906    if (element.hasExpressionElement()) {
18907      composeString(t, "SearchParameterComponentComponent", "expression", element.getExpressionElement(), -1);
18908    }
18909  }
18910
18911  protected void composeServiceRequest(Complex parent, String parentType, String name, ServiceRequest element, int index) {
18912    if (element == null) 
18913      return;
18914    Complex t;
18915    if (Utilities.noString(parentType))
18916      t = parent;
18917    else {
18918      t = parent.predicate("fhir:"+parentType+'.'+name);
18919    }
18920    composeDomainResource(t, "ServiceRequest", name, element, index);
18921    for (int i = 0; i < element.getIdentifier().size(); i++) {
18922      composeIdentifier(t, "ServiceRequest", "identifier", element.getIdentifier().get(i), i);
18923    }
18924    for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) {
18925      composeCanonical(t, "ServiceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i);
18926    }
18927    for (int i = 0; i < element.getInstantiatesUri().size(); i++) {
18928      composeUri(t, "ServiceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i);
18929    }
18930    for (int i = 0; i < element.getBasedOn().size(); i++) {
18931      composeReference(t, "ServiceRequest", "basedOn", element.getBasedOn().get(i), i);
18932    }
18933    for (int i = 0; i < element.getReplaces().size(); i++) {
18934      composeReference(t, "ServiceRequest", "replaces", element.getReplaces().get(i), i);
18935    }
18936    if (element.hasRequisition()) {
18937      composeIdentifier(t, "ServiceRequest", "requisition", element.getRequisition(), -1);
18938    }
18939    if (element.hasStatusElement()) {
18940      composeEnum(t, "ServiceRequest", "status", element.getStatusElement(), -1);
18941    }
18942    if (element.hasIntentElement()) {
18943      composeEnum(t, "ServiceRequest", "intent", element.getIntentElement(), -1);
18944    }
18945    for (int i = 0; i < element.getCategory().size(); i++) {
18946      composeCodeableConcept(t, "ServiceRequest", "category", element.getCategory().get(i), i);
18947    }
18948    if (element.hasPriorityElement()) {
18949      composeEnum(t, "ServiceRequest", "priority", element.getPriorityElement(), -1);
18950    }
18951    if (element.hasDoNotPerformElement()) {
18952      composeBoolean(t, "ServiceRequest", "doNotPerform", element.getDoNotPerformElement(), -1);
18953    }
18954    if (element.hasCode()) {
18955      composeCodeableConcept(t, "ServiceRequest", "code", element.getCode(), -1);
18956    }
18957    for (int i = 0; i < element.getOrderDetail().size(); i++) {
18958      composeCodeableConcept(t, "ServiceRequest", "orderDetail", element.getOrderDetail().get(i), i);
18959    }
18960    if (element.hasQuantity()) {
18961      composeType(t, "ServiceRequest", "quantity", element.getQuantity(), -1);
18962    }
18963    if (element.hasSubject()) {
18964      composeReference(t, "ServiceRequest", "subject", element.getSubject(), -1);
18965    }
18966    if (element.hasEncounter()) {
18967      composeReference(t, "ServiceRequest", "encounter", element.getEncounter(), -1);
18968    }
18969    if (element.hasOccurrence()) {
18970      composeType(t, "ServiceRequest", "occurrence", element.getOccurrence(), -1);
18971    }
18972    if (element.hasAsNeeded()) {
18973      composeType(t, "ServiceRequest", "asNeeded", element.getAsNeeded(), -1);
18974    }
18975    if (element.hasAuthoredOnElement()) {
18976      composeDateTime(t, "ServiceRequest", "authoredOn", element.getAuthoredOnElement(), -1);
18977    }
18978    if (element.hasRequester()) {
18979      composeReference(t, "ServiceRequest", "requester", element.getRequester(), -1);
18980    }
18981    if (element.hasPerformerType()) {
18982      composeCodeableConcept(t, "ServiceRequest", "performerType", element.getPerformerType(), -1);
18983    }
18984    for (int i = 0; i < element.getPerformer().size(); i++) {
18985      composeReference(t, "ServiceRequest", "performer", element.getPerformer().get(i), i);
18986    }
18987    for (int i = 0; i < element.getLocation().size(); i++) {
18988      composeCodeableReference(t, "ServiceRequest", "location", element.getLocation().get(i), i);
18989    }
18990    for (int i = 0; i < element.getReason().size(); i++) {
18991      composeCodeableReference(t, "ServiceRequest", "reason", element.getReason().get(i), i);
18992    }
18993    for (int i = 0; i < element.getInsurance().size(); i++) {
18994      composeReference(t, "ServiceRequest", "insurance", element.getInsurance().get(i), i);
18995    }
18996    for (int i = 0; i < element.getSupportingInfo().size(); i++) {
18997      composeReference(t, "ServiceRequest", "supportingInfo", element.getSupportingInfo().get(i), i);
18998    }
18999    for (int i = 0; i < element.getSpecimen().size(); i++) {
19000      composeReference(t, "ServiceRequest", "specimen", element.getSpecimen().get(i), i);
19001    }
19002    for (int i = 0; i < element.getBodySite().size(); i++) {
19003      composeCodeableConcept(t, "ServiceRequest", "bodySite", element.getBodySite().get(i), i);
19004    }
19005    for (int i = 0; i < element.getNote().size(); i++) {
19006      composeAnnotation(t, "ServiceRequest", "note", element.getNote().get(i), i);
19007    }
19008    if (element.hasPatientInstructionElement()) {
19009      composeString(t, "ServiceRequest", "patientInstruction", element.getPatientInstructionElement(), -1);
19010    }
19011    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
19012      composeReference(t, "ServiceRequest", "relevantHistory", element.getRelevantHistory().get(i), i);
19013    }
19014  }
19015
19016  protected void composeSlot(Complex parent, String parentType, String name, Slot element, int index) {
19017    if (element == null) 
19018      return;
19019    Complex t;
19020    if (Utilities.noString(parentType))
19021      t = parent;
19022    else {
19023      t = parent.predicate("fhir:"+parentType+'.'+name);
19024    }
19025    composeDomainResource(t, "Slot", name, element, index);
19026    for (int i = 0; i < element.getIdentifier().size(); i++) {
19027      composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i);
19028    }
19029    for (int i = 0; i < element.getServiceCategory().size(); i++) {
19030      composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory().get(i), i);
19031    }
19032    for (int i = 0; i < element.getServiceType().size(); i++) {
19033      composeCodeableConcept(t, "Slot", "serviceType", element.getServiceType().get(i), i);
19034    }
19035    for (int i = 0; i < element.getSpecialty().size(); i++) {
19036      composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i);
19037    }
19038    if (element.hasAppointmentType()) {
19039      composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType(), -1);
19040    }
19041    if (element.hasSchedule()) {
19042      composeReference(t, "Slot", "schedule", element.getSchedule(), -1);
19043    }
19044    if (element.hasStatusElement()) {
19045      composeEnum(t, "Slot", "status", element.getStatusElement(), -1);
19046    }
19047    if (element.hasStartElement()) {
19048      composeInstant(t, "Slot", "start", element.getStartElement(), -1);
19049    }
19050    if (element.hasEndElement()) {
19051      composeInstant(t, "Slot", "end", element.getEndElement(), -1);
19052    }
19053    if (element.hasOverbookedElement()) {
19054      composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1);
19055    }
19056    if (element.hasCommentElement()) {
19057      composeString(t, "Slot", "comment", element.getCommentElement(), -1);
19058    }
19059  }
19060
19061  protected void composeSpecimen(Complex parent, String parentType, String name, Specimen element, int index) {
19062    if (element == null) 
19063      return;
19064    Complex t;
19065    if (Utilities.noString(parentType))
19066      t = parent;
19067    else {
19068      t = parent.predicate("fhir:"+parentType+'.'+name);
19069    }
19070    composeDomainResource(t, "Specimen", name, element, index);
19071    for (int i = 0; i < element.getIdentifier().size(); i++) {
19072      composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i);
19073    }
19074    if (element.hasAccessionIdentifier()) {
19075      composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1);
19076    }
19077    if (element.hasStatusElement()) {
19078      composeEnum(t, "Specimen", "status", element.getStatusElement(), -1);
19079    }
19080    if (element.hasType()) {
19081      composeCodeableConcept(t, "Specimen", "type", element.getType(), -1);
19082    }
19083    if (element.hasSubject()) {
19084      composeReference(t, "Specimen", "subject", element.getSubject(), -1);
19085    }
19086    if (element.hasReceivedTimeElement()) {
19087      composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1);
19088    }
19089    for (int i = 0; i < element.getParent().size(); i++) {
19090      composeReference(t, "Specimen", "parent", element.getParent().get(i), i);
19091    }
19092    for (int i = 0; i < element.getRequest().size(); i++) {
19093      composeReference(t, "Specimen", "request", element.getRequest().get(i), i);
19094    }
19095    if (element.hasCollection()) {
19096      composeSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1);
19097    }
19098    for (int i = 0; i < element.getProcessing().size(); i++) {
19099      composeSpecimenProcessingComponent(t, "Specimen", "processing", element.getProcessing().get(i), i);
19100    }
19101    for (int i = 0; i < element.getContainer().size(); i++) {
19102      composeSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i);
19103    }
19104    for (int i = 0; i < element.getCondition().size(); i++) {
19105      composeCodeableConcept(t, "Specimen", "condition", element.getCondition().get(i), i);
19106    }
19107    for (int i = 0; i < element.getNote().size(); i++) {
19108      composeAnnotation(t, "Specimen", "note", element.getNote().get(i), i);
19109    }
19110  }
19111
19112  protected void composeSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent element, int index) {
19113    if (element == null) 
19114      return;
19115    Complex t;
19116    if (Utilities.noString(parentType))
19117      t = parent;
19118    else {
19119      t = parent.predicate("fhir:"+parentType+'.'+name);
19120    }
19121    composeBackboneElement(t, "collection", name, element, index);
19122    if (element.hasCollector()) {
19123      composeReference(t, "SpecimenCollectionComponent", "collector", element.getCollector(), -1);
19124    }
19125    if (element.hasCollected()) {
19126      composeType(t, "SpecimenCollectionComponent", "collected", element.getCollected(), -1);
19127    }
19128    if (element.hasDuration()) {
19129      composeDuration(t, "SpecimenCollectionComponent", "duration", element.getDuration(), -1);
19130    }
19131    if (element.hasQuantity()) {
19132      composeQuantity(t, "SpecimenCollectionComponent", "quantity", element.getQuantity(), -1);
19133    }
19134    if (element.hasMethod()) {
19135      composeCodeableConcept(t, "SpecimenCollectionComponent", "method", element.getMethod(), -1);
19136    }
19137    if (element.hasBodySite()) {
19138      composeCodeableConcept(t, "SpecimenCollectionComponent", "bodySite", element.getBodySite(), -1);
19139    }
19140    if (element.hasFastingStatus()) {
19141      composeType(t, "SpecimenCollectionComponent", "fastingStatus", element.getFastingStatus(), -1);
19142    }
19143  }
19144
19145  protected void composeSpecimenProcessingComponent(Complex parent, String parentType, String name, Specimen.SpecimenProcessingComponent element, int index) {
19146    if (element == null) 
19147      return;
19148    Complex t;
19149    if (Utilities.noString(parentType))
19150      t = parent;
19151    else {
19152      t = parent.predicate("fhir:"+parentType+'.'+name);
19153    }
19154    composeBackboneElement(t, "processing", name, element, index);
19155    if (element.hasDescriptionElement()) {
19156      composeString(t, "SpecimenProcessingComponent", "description", element.getDescriptionElement(), -1);
19157    }
19158    if (element.hasProcedure()) {
19159      composeCodeableConcept(t, "SpecimenProcessingComponent", "procedure", element.getProcedure(), -1);
19160    }
19161    for (int i = 0; i < element.getAdditive().size(); i++) {
19162      composeReference(t, "SpecimenProcessingComponent", "additive", element.getAdditive().get(i), i);
19163    }
19164    if (element.hasTime()) {
19165      composeType(t, "SpecimenProcessingComponent", "time", element.getTime(), -1);
19166    }
19167  }
19168
19169  protected void composeSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent element, int index) {
19170    if (element == null) 
19171      return;
19172    Complex t;
19173    if (Utilities.noString(parentType))
19174      t = parent;
19175    else {
19176      t = parent.predicate("fhir:"+parentType+'.'+name);
19177    }
19178    composeBackboneElement(t, "container", name, element, index);
19179    for (int i = 0; i < element.getIdentifier().size(); i++) {
19180      composeIdentifier(t, "SpecimenContainerComponent", "identifier", element.getIdentifier().get(i), i);
19181    }
19182    if (element.hasDescriptionElement()) {
19183      composeString(t, "SpecimenContainerComponent", "description", element.getDescriptionElement(), -1);
19184    }
19185    if (element.hasType()) {
19186      composeCodeableConcept(t, "SpecimenContainerComponent", "type", element.getType(), -1);
19187    }
19188    if (element.hasCapacity()) {
19189      composeQuantity(t, "SpecimenContainerComponent", "capacity", element.getCapacity(), -1);
19190    }
19191    if (element.hasSpecimenQuantity()) {
19192      composeQuantity(t, "SpecimenContainerComponent", "specimenQuantity", element.getSpecimenQuantity(), -1);
19193    }
19194    if (element.hasAdditive()) {
19195      composeType(t, "SpecimenContainerComponent", "additive", element.getAdditive(), -1);
19196    }
19197  }
19198
19199  protected void composeSpecimenDefinition(Complex parent, String parentType, String name, SpecimenDefinition element, int index) {
19200    if (element == null) 
19201      return;
19202    Complex t;
19203    if (Utilities.noString(parentType))
19204      t = parent;
19205    else {
19206      t = parent.predicate("fhir:"+parentType+'.'+name);
19207    }
19208    composeDomainResource(t, "SpecimenDefinition", name, element, index);
19209    if (element.hasUrlElement()) {
19210      composeUri(t, "SpecimenDefinition", "url", element.getUrlElement(), -1);
19211    }
19212    if (element.hasIdentifier()) {
19213      composeIdentifier(t, "SpecimenDefinition", "identifier", element.getIdentifier(), -1);
19214    }
19215    if (element.hasVersionElement()) {
19216      composeString(t, "SpecimenDefinition", "version", element.getVersionElement(), -1);
19217    }
19218    if (element.hasTitleElement()) {
19219      composeString(t, "SpecimenDefinition", "title", element.getTitleElement(), -1);
19220    }
19221    for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) {
19222      composeCanonical(t, "SpecimenDefinition", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i);
19223    }
19224    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
19225      composeUri(t, "SpecimenDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i);
19226    }
19227    if (element.hasStatusElement()) {
19228      composeEnum(t, "SpecimenDefinition", "status", element.getStatusElement(), -1);
19229    }
19230    if (element.hasExperimentalElement()) {
19231      composeBoolean(t, "SpecimenDefinition", "experimental", element.getExperimentalElement(), -1);
19232    }
19233    if (element.hasSubject()) {
19234      composeType(t, "SpecimenDefinition", "subject", element.getSubject(), -1);
19235    }
19236    if (element.hasDateElement()) {
19237      composeDateTime(t, "SpecimenDefinition", "date", element.getDateElement(), -1);
19238    }
19239    if (element.hasPublisher()) {
19240      composeReference(t, "SpecimenDefinition", "publisher", element.getPublisher(), -1);
19241    }
19242    for (int i = 0; i < element.getContact().size(); i++) {
19243      composeContactDetail(t, "SpecimenDefinition", "contact", element.getContact().get(i), i);
19244    }
19245    if (element.hasDescriptionElement()) {
19246      composeMarkdown(t, "SpecimenDefinition", "description", element.getDescriptionElement(), -1);
19247    }
19248    for (int i = 0; i < element.getUseContext().size(); i++) {
19249      composeUsageContext(t, "SpecimenDefinition", "useContext", element.getUseContext().get(i), i);
19250    }
19251    for (int i = 0; i < element.getJurisdiction().size(); i++) {
19252      composeCodeableConcept(t, "SpecimenDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
19253    }
19254    if (element.hasPurposeElement()) {
19255      composeMarkdown(t, "SpecimenDefinition", "purpose", element.getPurposeElement(), -1);
19256    }
19257    if (element.hasCopyrightElement()) {
19258      composeMarkdown(t, "SpecimenDefinition", "copyright", element.getCopyrightElement(), -1);
19259    }
19260    if (element.hasApprovalDateElement()) {
19261      composeDate(t, "SpecimenDefinition", "approvalDate", element.getApprovalDateElement(), -1);
19262    }
19263    if (element.hasLastReviewDateElement()) {
19264      composeDate(t, "SpecimenDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1);
19265    }
19266    if (element.hasEffectivePeriod()) {
19267      composePeriod(t, "SpecimenDefinition", "effectivePeriod", element.getEffectivePeriod(), -1);
19268    }
19269    if (element.hasTypeCollected()) {
19270      composeCodeableConcept(t, "SpecimenDefinition", "typeCollected", element.getTypeCollected(), -1);
19271    }
19272    for (int i = 0; i < element.getPatientPreparation().size(); i++) {
19273      composeCodeableConcept(t, "SpecimenDefinition", "patientPreparation", element.getPatientPreparation().get(i), i);
19274    }
19275    if (element.hasTimeAspectElement()) {
19276      composeString(t, "SpecimenDefinition", "timeAspect", element.getTimeAspectElement(), -1);
19277    }
19278    for (int i = 0; i < element.getCollection().size(); i++) {
19279      composeCodeableConcept(t, "SpecimenDefinition", "collection", element.getCollection().get(i), i);
19280    }
19281    for (int i = 0; i < element.getTypeTested().size(); i++) {
19282      composeSpecimenDefinitionTypeTestedComponent(t, "SpecimenDefinition", "typeTested", element.getTypeTested().get(i), i);
19283    }
19284  }
19285
19286  protected void composeSpecimenDefinitionTypeTestedComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedComponent element, int index) {
19287    if (element == null) 
19288      return;
19289    Complex t;
19290    if (Utilities.noString(parentType))
19291      t = parent;
19292    else {
19293      t = parent.predicate("fhir:"+parentType+'.'+name);
19294    }
19295    composeBackboneElement(t, "typeTested", name, element, index);
19296    if (element.hasIsDerivedElement()) {
19297      composeBoolean(t, "SpecimenDefinitionTypeTestedComponent", "isDerived", element.getIsDerivedElement(), -1);
19298    }
19299    if (element.hasType()) {
19300      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "type", element.getType(), -1);
19301    }
19302    if (element.hasPreferenceElement()) {
19303      composeEnum(t, "SpecimenDefinitionTypeTestedComponent", "preference", element.getPreferenceElement(), -1);
19304    }
19305    if (element.hasContainer()) {
19306      composeSpecimenDefinitionTypeTestedContainerComponent(t, "SpecimenDefinitionTypeTestedComponent", "container", element.getContainer(), -1);
19307    }
19308    if (element.hasRequirementElement()) {
19309      composeString(t, "SpecimenDefinitionTypeTestedComponent", "requirement", element.getRequirementElement(), -1);
19310    }
19311    if (element.hasRetentionTime()) {
19312      composeDuration(t, "SpecimenDefinitionTypeTestedComponent", "retentionTime", element.getRetentionTime(), -1);
19313    }
19314    if (element.hasSingleUseElement()) {
19315      composeBoolean(t, "SpecimenDefinitionTypeTestedComponent", "singleUse", element.getSingleUseElement(), -1);
19316    }
19317    for (int i = 0; i < element.getRejectionCriterion().size(); i++) {
19318      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "rejectionCriterion", element.getRejectionCriterion().get(i), i);
19319    }
19320    for (int i = 0; i < element.getHandling().size(); i++) {
19321      composeSpecimenDefinitionTypeTestedHandlingComponent(t, "SpecimenDefinitionTypeTestedComponent", "handling", element.getHandling().get(i), i);
19322    }
19323    for (int i = 0; i < element.getTestingDestination().size(); i++) {
19324      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "testingDestination", element.getTestingDestination().get(i), i);
19325    }
19326  }
19327
19328  protected void composeSpecimenDefinitionTypeTestedContainerComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerComponent element, int index) {
19329    if (element == null) 
19330      return;
19331    Complex t;
19332    if (Utilities.noString(parentType))
19333      t = parent;
19334    else {
19335      t = parent.predicate("fhir:"+parentType+'.'+name);
19336    }
19337    composeBackboneElement(t, "container", name, element, index);
19338    if (element.hasMaterial()) {
19339      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "material", element.getMaterial(), -1);
19340    }
19341    if (element.hasType()) {
19342      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "type", element.getType(), -1);
19343    }
19344    if (element.hasCap()) {
19345      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "cap", element.getCap(), -1);
19346    }
19347    if (element.hasDescriptionElement()) {
19348      composeString(t, "SpecimenDefinitionTypeTestedContainerComponent", "description", element.getDescriptionElement(), -1);
19349    }
19350    if (element.hasCapacity()) {
19351      composeQuantity(t, "SpecimenDefinitionTypeTestedContainerComponent", "capacity", element.getCapacity(), -1);
19352    }
19353    if (element.hasMinimumVolume()) {
19354      composeType(t, "SpecimenDefinitionTypeTestedContainerComponent", "minimumVolume", element.getMinimumVolume(), -1);
19355    }
19356    for (int i = 0; i < element.getAdditive().size(); i++) {
19357      composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(t, "SpecimenDefinitionTypeTestedContainerComponent", "additive", element.getAdditive().get(i), i);
19358    }
19359    if (element.hasPreparationElement()) {
19360      composeString(t, "SpecimenDefinitionTypeTestedContainerComponent", "preparation", element.getPreparationElement(), -1);
19361    }
19362  }
19363
19364  protected void composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerAdditiveComponent element, int index) {
19365    if (element == null) 
19366      return;
19367    Complex t;
19368    if (Utilities.noString(parentType))
19369      t = parent;
19370    else {
19371      t = parent.predicate("fhir:"+parentType+'.'+name);
19372    }
19373    composeBackboneElement(t, "additive", name, element, index);
19374    if (element.hasAdditive()) {
19375      composeType(t, "SpecimenDefinitionTypeTestedContainerAdditiveComponent", "additive", element.getAdditive(), -1);
19376    }
19377  }
19378
19379  protected void composeSpecimenDefinitionTypeTestedHandlingComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedHandlingComponent element, int index) {
19380    if (element == null) 
19381      return;
19382    Complex t;
19383    if (Utilities.noString(parentType))
19384      t = parent;
19385    else {
19386      t = parent.predicate("fhir:"+parentType+'.'+name);
19387    }
19388    composeBackboneElement(t, "handling", name, element, index);
19389    if (element.hasTemperatureQualifier()) {
19390      composeCodeableConcept(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureQualifier", element.getTemperatureQualifier(), -1);
19391    }
19392    if (element.hasTemperatureRange()) {
19393      composeRange(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureRange", element.getTemperatureRange(), -1);
19394    }
19395    if (element.hasMaxDuration()) {
19396      composeDuration(t, "SpecimenDefinitionTypeTestedHandlingComponent", "maxDuration", element.getMaxDuration(), -1);
19397    }
19398    if (element.hasInstructionElement()) {
19399      composeString(t, "SpecimenDefinitionTypeTestedHandlingComponent", "instruction", element.getInstructionElement(), -1);
19400    }
19401  }
19402
19403  protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition element, int index) {
19404    if (element == null) 
19405      return;
19406    Complex t;
19407    if (Utilities.noString(parentType))
19408      t = parent;
19409    else {
19410      t = parent.predicate("fhir:"+parentType+'.'+name);
19411    }
19412    composeCanonicalResource(t, "StructureDefinition", name, element, index);
19413    if (element.hasUrlElement()) {
19414      composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1);
19415    }
19416    for (int i = 0; i < element.getIdentifier().size(); i++) {
19417      composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i);
19418    }
19419    if (element.hasVersionElement()) {
19420      composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1);
19421    }
19422    if (element.hasNameElement()) {
19423      composeString(t, "StructureDefinition", "name", element.getNameElement(), -1);
19424    }
19425    if (element.hasTitleElement()) {
19426      composeString(t, "StructureDefinition", "title", element.getTitleElement(), -1);
19427    }
19428    if (element.hasStatusElement()) {
19429      composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1);
19430    }
19431    if (element.hasExperimentalElement()) {
19432      composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1);
19433    }
19434    if (element.hasDateElement()) {
19435      composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1);
19436    }
19437    if (element.hasPublisherElement()) {
19438      composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1);
19439    }
19440    for (int i = 0; i < element.getContact().size(); i++) {
19441      composeContactDetail(t, "StructureDefinition", "contact", element.getContact().get(i), i);
19442    }
19443    if (element.hasDescriptionElement()) {
19444      composeMarkdown(t, "StructureDefinition", "description", element.getDescriptionElement(), -1);
19445    }
19446    for (int i = 0; i < element.getUseContext().size(); i++) {
19447      composeUsageContext(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i);
19448    }
19449    for (int i = 0; i < element.getJurisdiction().size(); i++) {
19450      composeCodeableConcept(t, "StructureDefinition", "jurisdiction", element.getJurisdiction().get(i), i);
19451    }
19452    if (element.hasPurposeElement()) {
19453      composeMarkdown(t, "StructureDefinition", "purpose", element.getPurposeElement(), -1);
19454    }
19455    if (element.hasCopyrightElement()) {
19456      composeMarkdown(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1);
19457    }
19458    for (int i = 0; i < element.getKeyword().size(); i++) {
19459      composeCoding(t, "StructureDefinition", "keyword", element.getKeyword().get(i), i);
19460    }
19461    if (element.hasFhirVersionElement()) {
19462      composeEnum(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1);
19463    }
19464    for (int i = 0; i < element.getMapping().size(); i++) {
19465      composeStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i);
19466    }
19467    if (element.hasKindElement()) {
19468      composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1);
19469    }
19470    if (element.hasAbstractElement()) {
19471      composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1);
19472    }
19473    for (int i = 0; i < element.getContext().size(); i++) {
19474      composeStructureDefinitionContextComponent(t, "StructureDefinition", "context", element.getContext().get(i), i);
19475    }
19476    for (int i = 0; i < element.getContextInvariant().size(); i++) {
19477      composeString(t, "StructureDefinition", "contextInvariant", element.getContextInvariant().get(i), i);
19478    }
19479    if (element.hasTypeElement()) {
19480      composeUri(t, "StructureDefinition", "type", element.getTypeElement(), -1);
19481    }
19482    if (element.hasBaseDefinitionElement()) {
19483      composeCanonical(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1);
19484    }
19485    if (element.hasDerivationElement()) {
19486      composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1);
19487    }
19488    if (element.hasSnapshot()) {
19489      composeStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1);
19490    }
19491    if (element.hasDifferential()) {
19492      composeStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1);
19493    }
19494  }
19495
19496  protected void composeStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent element, int index) {
19497    if (element == null) 
19498      return;
19499    Complex t;
19500    if (Utilities.noString(parentType))
19501      t = parent;
19502    else {
19503      t = parent.predicate("fhir:"+parentType+'.'+name);
19504    }
19505    composeBackboneElement(t, "mapping", name, element, index);
19506    if (element.hasIdentityElement()) {
19507      composeId(t, "StructureDefinitionMappingComponent", "identity", element.getIdentityElement(), -1);
19508    }
19509    if (element.hasUriElement()) {
19510      composeUri(t, "StructureDefinitionMappingComponent", "uri", element.getUriElement(), -1);
19511    }
19512    if (element.hasNameElement()) {
19513      composeString(t, "StructureDefinitionMappingComponent", "name", element.getNameElement(), -1);
19514    }
19515    if (element.hasCommentElement()) {
19516      composeString(t, "StructureDefinitionMappingComponent", "comment", element.getCommentElement(), -1);
19517    }
19518  }
19519
19520  protected void composeStructureDefinitionContextComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionContextComponent element, int index) {
19521    if (element == null) 
19522      return;
19523    Complex t;
19524    if (Utilities.noString(parentType))
19525      t = parent;
19526    else {
19527      t = parent.predicate("fhir:"+parentType+'.'+name);
19528    }
19529    composeBackboneElement(t, "context", name, element, index);
19530    if (element.hasTypeElement()) {
19531      composeEnum(t, "StructureDefinitionContextComponent", "type", element.getTypeElement(), -1);
19532    }
19533    if (element.hasExpressionElement()) {
19534      composeString(t, "StructureDefinitionContextComponent", "expression", element.getExpressionElement(), -1);
19535    }
19536  }
19537
19538  protected void composeStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent element, int index) {
19539    if (element == null) 
19540      return;
19541    Complex t;
19542    if (Utilities.noString(parentType))
19543      t = parent;
19544    else {
19545      t = parent.predicate("fhir:"+parentType+'.'+name);
19546    }
19547    composeBackboneElement(t, "snapshot", name, element, index);
19548    for (int i = 0; i < element.getElement().size(); i++) {
19549      composeElementDefinition(t, "StructureDefinitionSnapshotComponent", "element", element.getElement().get(i), i);
19550    }
19551  }
19552
19553  protected void composeStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent element, int index) {
19554    if (element == null) 
19555      return;
19556    Complex t;
19557    if (Utilities.noString(parentType))
19558      t = parent;
19559    else {
19560      t = parent.predicate("fhir:"+parentType+'.'+name);
19561    }
19562    composeBackboneElement(t, "differential", name, element, index);
19563    for (int i = 0; i < element.getElement().size(); i++) {
19564      composeElementDefinition(t, "StructureDefinitionDifferentialComponent", "element", element.getElement().get(i), i);
19565    }
19566  }
19567
19568  protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap element, int index) {
19569    if (element == null) 
19570      return;
19571    Complex t;
19572    if (Utilities.noString(parentType))
19573      t = parent;
19574    else {
19575      t = parent.predicate("fhir:"+parentType+'.'+name);
19576    }
19577    composeCanonicalResource(t, "StructureMap", name, element, index);
19578    if (element.hasUrlElement()) {
19579      composeUri(t, "StructureMap", "url", element.getUrlElement(), -1);
19580    }
19581    for (int i = 0; i < element.getIdentifier().size(); i++) {
19582      composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i);
19583    }
19584    if (element.hasVersionElement()) {
19585      composeString(t, "StructureMap", "version", element.getVersionElement(), -1);
19586    }
19587    if (element.hasNameElement()) {
19588      composeString(t, "StructureMap", "name", element.getNameElement(), -1);
19589    }
19590    if (element.hasTitleElement()) {
19591      composeString(t, "StructureMap", "title", element.getTitleElement(), -1);
19592    }
19593    if (element.hasStatusElement()) {
19594      composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1);
19595    }
19596    if (element.hasExperimentalElement()) {
19597      composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1);
19598    }
19599    if (element.hasDateElement()) {
19600      composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1);
19601    }
19602    if (element.hasPublisherElement()) {
19603      composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1);
19604    }
19605    for (int i = 0; i < element.getContact().size(); i++) {
19606      composeContactDetail(t, "StructureMap", "contact", element.getContact().get(i), i);
19607    }
19608    if (element.hasDescriptionElement()) {
19609      composeMarkdown(t, "StructureMap", "description", element.getDescriptionElement(), -1);
19610    }
19611    for (int i = 0; i < element.getUseContext().size(); i++) {
19612      composeUsageContext(t, "StructureMap", "useContext", element.getUseContext().get(i), i);
19613    }
19614    for (int i = 0; i < element.getJurisdiction().size(); i++) {
19615      composeCodeableConcept(t, "StructureMap", "jurisdiction", element.getJurisdiction().get(i), i);
19616    }
19617    if (element.hasPurposeElement()) {
19618      composeMarkdown(t, "StructureMap", "purpose", element.getPurposeElement(), -1);
19619    }
19620    if (element.hasCopyrightElement()) {
19621      composeMarkdown(t, "StructureMap", "copyright", element.getCopyrightElement(), -1);
19622    }
19623    for (int i = 0; i < element.getStructure().size(); i++) {
19624      composeStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i);
19625    }
19626    for (int i = 0; i < element.getImport().size(); i++) {
19627      composeCanonical(t, "StructureMap", "import", element.getImport().get(i), i);
19628    }
19629    for (int i = 0; i < element.getGroup().size(); i++) {
19630      composeStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i);
19631    }
19632  }
19633
19634  protected void composeStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent element, int index) {
19635    if (element == null) 
19636      return;
19637    Complex t;
19638    if (Utilities.noString(parentType))
19639      t = parent;
19640    else {
19641      t = parent.predicate("fhir:"+parentType+'.'+name);
19642    }
19643    composeBackboneElement(t, "structure", name, element, index);
19644    if (element.hasUrlElement()) {
19645      composeCanonical(t, "StructureMapStructureComponent", "url", element.getUrlElement(), -1);
19646    }
19647    if (element.hasModeElement()) {
19648      composeEnum(t, "StructureMapStructureComponent", "mode", element.getModeElement(), -1);
19649    }
19650    if (element.hasAliasElement()) {
19651      composeString(t, "StructureMapStructureComponent", "alias", element.getAliasElement(), -1);
19652    }
19653    if (element.hasDocumentationElement()) {
19654      composeString(t, "StructureMapStructureComponent", "documentation", element.getDocumentationElement(), -1);
19655    }
19656  }
19657
19658  protected void composeStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent element, int index) {
19659    if (element == null) 
19660      return;
19661    Complex t;
19662    if (Utilities.noString(parentType))
19663      t = parent;
19664    else {
19665      t = parent.predicate("fhir:"+parentType+'.'+name);
19666    }
19667    composeBackboneElement(t, "group", name, element, index);
19668    if (element.hasNameElement()) {
19669      composeId(t, "StructureMapGroupComponent", "name", element.getNameElement(), -1);
19670    }
19671    if (element.hasExtendsElement()) {
19672      composeId(t, "StructureMapGroupComponent", "extends", element.getExtendsElement(), -1);
19673    }
19674    if (element.hasTypeModeElement()) {
19675      composeEnum(t, "StructureMapGroupComponent", "typeMode", element.getTypeModeElement(), -1);
19676    }
19677    if (element.hasDocumentationElement()) {
19678      composeString(t, "StructureMapGroupComponent", "documentation", element.getDocumentationElement(), -1);
19679    }
19680    for (int i = 0; i < element.getInput().size(); i++) {
19681      composeStructureMapGroupInputComponent(t, "StructureMapGroupComponent", "input", element.getInput().get(i), i);
19682    }
19683    for (int i = 0; i < element.getRule().size(); i++) {
19684      composeStructureMapGroupRuleComponent(t, "StructureMapGroupComponent", "rule", element.getRule().get(i), i);
19685    }
19686  }
19687
19688  protected void composeStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent element, int index) {
19689    if (element == null) 
19690      return;
19691    Complex t;
19692    if (Utilities.noString(parentType))
19693      t = parent;
19694    else {
19695      t = parent.predicate("fhir:"+parentType+'.'+name);
19696    }
19697    composeBackboneElement(t, "input", name, element, index);
19698    if (element.hasNameElement()) {
19699      composeId(t, "StructureMapGroupInputComponent", "name", element.getNameElement(), -1);
19700    }
19701    if (element.hasTypeElement()) {
19702      composeString(t, "StructureMapGroupInputComponent", "type", element.getTypeElement(), -1);
19703    }
19704    if (element.hasModeElement()) {
19705      composeEnum(t, "StructureMapGroupInputComponent", "mode", element.getModeElement(), -1);
19706    }
19707    if (element.hasDocumentationElement()) {
19708      composeString(t, "StructureMapGroupInputComponent", "documentation", element.getDocumentationElement(), -1);
19709    }
19710  }
19711
19712  protected void composeStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent element, int index) {
19713    if (element == null) 
19714      return;
19715    Complex t;
19716    if (Utilities.noString(parentType))
19717      t = parent;
19718    else {
19719      t = parent.predicate("fhir:"+parentType+'.'+name);
19720    }
19721    composeBackboneElement(t, "rule", name, element, index);
19722    if (element.hasNameElement()) {
19723      composeId(t, "StructureMapGroupRuleComponent", "name", element.getNameElement(), -1);
19724    }
19725    for (int i = 0; i < element.getSource().size(); i++) {
19726      composeStructureMapGroupRuleSourceComponent(t, "StructureMapGroupRuleComponent", "source", element.getSource().get(i), i);
19727    }
19728    for (int i = 0; i < element.getTarget().size(); i++) {
19729      composeStructureMapGroupRuleTargetComponent(t, "StructureMapGroupRuleComponent", "target", element.getTarget().get(i), i);
19730    }
19731    for (int i = 0; i < element.getRule().size(); i++) {
19732      composeStructureMapGroupRuleComponent(t, "StructureMapGroupRuleComponent", "rule", element.getRule().get(i), i);
19733    }
19734    for (int i = 0; i < element.getDependent().size(); i++) {
19735      composeStructureMapGroupRuleDependentComponent(t, "StructureMapGroupRuleComponent", "dependent", element.getDependent().get(i), i);
19736    }
19737    if (element.hasDocumentationElement()) {
19738      composeString(t, "StructureMapGroupRuleComponent", "documentation", element.getDocumentationElement(), -1);
19739    }
19740  }
19741
19742  protected void composeStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent element, int index) {
19743    if (element == null) 
19744      return;
19745    Complex t;
19746    if (Utilities.noString(parentType))
19747      t = parent;
19748    else {
19749      t = parent.predicate("fhir:"+parentType+'.'+name);
19750    }
19751    composeBackboneElement(t, "source", name, element, index);
19752    if (element.hasContextElement()) {
19753      composeId(t, "StructureMapGroupRuleSourceComponent", "context", element.getContextElement(), -1);
19754    }
19755    if (element.hasMinElement()) {
19756      composeInteger(t, "StructureMapGroupRuleSourceComponent", "min", element.getMinElement(), -1);
19757    }
19758    if (element.hasMaxElement()) {
19759      composeString(t, "StructureMapGroupRuleSourceComponent", "max", element.getMaxElement(), -1);
19760    }
19761    if (element.hasTypeElement()) {
19762      composeString(t, "StructureMapGroupRuleSourceComponent", "type", element.getTypeElement(), -1);
19763    }
19764    if (element.hasDefaultValue()) {
19765      composeType(t, "StructureMapGroupRuleSourceComponent", "defaultValue", element.getDefaultValue(), -1);
19766    }
19767    if (element.hasElementElement()) {
19768      composeString(t, "StructureMapGroupRuleSourceComponent", "element", element.getElementElement(), -1);
19769    }
19770    if (element.hasListModeElement()) {
19771      composeEnum(t, "StructureMapGroupRuleSourceComponent", "listMode", element.getListModeElement(), -1);
19772    }
19773    if (element.hasVariableElement()) {
19774      composeId(t, "StructureMapGroupRuleSourceComponent", "variable", element.getVariableElement(), -1);
19775    }
19776    if (element.hasConditionElement()) {
19777      composeString(t, "StructureMapGroupRuleSourceComponent", "condition", element.getConditionElement(), -1);
19778    }
19779    if (element.hasCheckElement()) {
19780      composeString(t, "StructureMapGroupRuleSourceComponent", "check", element.getCheckElement(), -1);
19781    }
19782    if (element.hasLogMessageElement()) {
19783      composeString(t, "StructureMapGroupRuleSourceComponent", "logMessage", element.getLogMessageElement(), -1);
19784    }
19785  }
19786
19787  protected void composeStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent element, int index) {
19788    if (element == null) 
19789      return;
19790    Complex t;
19791    if (Utilities.noString(parentType))
19792      t = parent;
19793    else {
19794      t = parent.predicate("fhir:"+parentType+'.'+name);
19795    }
19796    composeBackboneElement(t, "target", name, element, index);
19797    if (element.hasContextElement()) {
19798      composeId(t, "StructureMapGroupRuleTargetComponent", "context", element.getContextElement(), -1);
19799    }
19800    if (element.hasContextTypeElement()) {
19801      composeEnum(t, "StructureMapGroupRuleTargetComponent", "contextType", element.getContextTypeElement(), -1);
19802    }
19803    if (element.hasElementElement()) {
19804      composeString(t, "StructureMapGroupRuleTargetComponent", "element", element.getElementElement(), -1);
19805    }
19806    if (element.hasVariableElement()) {
19807      composeId(t, "StructureMapGroupRuleTargetComponent", "variable", element.getVariableElement(), -1);
19808    }
19809    for (int i = 0; i < element.getListMode().size(); i++) {
19810      composeEnum(t, "StructureMapGroupRuleTargetComponent", "listMode", element.getListMode().get(i), i);
19811    }
19812    if (element.hasListRuleIdElement()) {
19813      composeId(t, "StructureMapGroupRuleTargetComponent", "listRuleId", element.getListRuleIdElement(), -1);
19814    }
19815    if (element.hasTransformElement()) {
19816      composeEnum(t, "StructureMapGroupRuleTargetComponent", "transform", element.getTransformElement(), -1);
19817    }
19818    for (int i = 0; i < element.getParameter().size(); i++) {
19819      composeStructureMapGroupRuleTargetParameterComponent(t, "StructureMapGroupRuleTargetComponent", "parameter", element.getParameter().get(i), i);
19820    }
19821  }
19822
19823  protected void composeStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element, int index) {
19824    if (element == null) 
19825      return;
19826    Complex t;
19827    if (Utilities.noString(parentType))
19828      t = parent;
19829    else {
19830      t = parent.predicate("fhir:"+parentType+'.'+name);
19831    }
19832    composeBackboneElement(t, "parameter", name, element, index);
19833    if (element.hasValue()) {
19834      composeType(t, "StructureMapGroupRuleTargetParameterComponent", "value", element.getValue(), -1);
19835    }
19836  }
19837
19838  protected void composeStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent element, int index) {
19839    if (element == null) 
19840      return;
19841    Complex t;
19842    if (Utilities.noString(parentType))
19843      t = parent;
19844    else {
19845      t = parent.predicate("fhir:"+parentType+'.'+name);
19846    }
19847    composeBackboneElement(t, "dependent", name, element, index);
19848    if (element.hasNameElement()) {
19849      composeId(t, "StructureMapGroupRuleDependentComponent", "name", element.getNameElement(), -1);
19850    }
19851    for (int i = 0; i < element.getVariable().size(); i++) {
19852      composeString(t, "StructureMapGroupRuleDependentComponent", "variable", element.getVariable().get(i), i);
19853    }
19854  }
19855
19856  protected void composeSubscription(Complex parent, String parentType, String name, Subscription element, int index) {
19857    if (element == null) 
19858      return;
19859    Complex t;
19860    if (Utilities.noString(parentType))
19861      t = parent;
19862    else {
19863      t = parent.predicate("fhir:"+parentType+'.'+name);
19864    }
19865    composeDomainResource(t, "Subscription", name, element, index);
19866    for (int i = 0; i < element.getIdentifier().size(); i++) {
19867      composeIdentifier(t, "Subscription", "identifier", element.getIdentifier().get(i), i);
19868    }
19869    if (element.hasNameElement()) {
19870      composeString(t, "Subscription", "name", element.getNameElement(), -1);
19871    }
19872    if (element.hasStatusElement()) {
19873      composeEnum(t, "Subscription", "status", element.getStatusElement(), -1);
19874    }
19875    if (element.hasTopic()) {
19876      composeReference(t, "Subscription", "topic", element.getTopic(), -1);
19877    }
19878    for (int i = 0; i < element.getContact().size(); i++) {
19879      composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i);
19880    }
19881    if (element.hasEndElement()) {
19882      composeInstant(t, "Subscription", "end", element.getEndElement(), -1);
19883    }
19884    if (element.hasReasonElement()) {
19885      composeString(t, "Subscription", "reason", element.getReasonElement(), -1);
19886    }
19887    for (int i = 0; i < element.getFilterBy().size(); i++) {
19888      composeSubscriptionFilterByComponent(t, "Subscription", "filterBy", element.getFilterBy().get(i), i);
19889    }
19890    for (int i = 0; i < element.getError().size(); i++) {
19891      composeCodeableConcept(t, "Subscription", "error", element.getError().get(i), i);
19892    }
19893    if (element.hasEventCountElement()) {
19894      composeUnsignedInt(t, "Subscription", "eventCount", element.getEventCountElement(), -1);
19895    }
19896    if (element.hasChannel()) {
19897      composeSubscriptionChannelComponent(t, "Subscription", "channel", element.getChannel(), -1);
19898    }
19899  }
19900
19901  protected void composeSubscriptionFilterByComponent(Complex parent, String parentType, String name, Subscription.SubscriptionFilterByComponent element, int index) {
19902    if (element == null) 
19903      return;
19904    Complex t;
19905    if (Utilities.noString(parentType))
19906      t = parent;
19907    else {
19908      t = parent.predicate("fhir:"+parentType+'.'+name);
19909    }
19910    composeBackboneElement(t, "filterBy", name, element, index);
19911    if (element.hasNameElement()) {
19912      composeString(t, "SubscriptionFilterByComponent", "name", element.getNameElement(), -1);
19913    }
19914    if (element.hasMatchTypeElement()) {
19915      composeEnum(t, "SubscriptionFilterByComponent", "matchType", element.getMatchTypeElement(), -1);
19916    }
19917    if (element.hasValueElement()) {
19918      composeString(t, "SubscriptionFilterByComponent", "value", element.getValueElement(), -1);
19919    }
19920  }
19921
19922  protected void composeSubscriptionChannelComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelComponent 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    composeBackboneElement(t, "channel", name, element, index);
19932    if (element.hasType()) {
19933      composeCodeableConcept(t, "SubscriptionChannelComponent", "type", element.getType(), -1);
19934    }
19935    if (element.hasEndpointElement()) {
19936      composeUrl(t, "SubscriptionChannelComponent", "endpoint", element.getEndpointElement(), -1);
19937    }
19938    for (int i = 0; i < element.getHeader().size(); i++) {
19939      composeString(t, "SubscriptionChannelComponent", "header", element.getHeader().get(i), i);
19940    }
19941    if (element.hasHeartbeatPeriodElement()) {
19942      composeUnsignedInt(t, "SubscriptionChannelComponent", "heartbeatPeriod", element.getHeartbeatPeriodElement(), -1);
19943    }
19944    if (element.hasPayload()) {
19945      composeSubscriptionChannelPayloadComponent(t, "SubscriptionChannelComponent", "payload", element.getPayload(), -1);
19946    }
19947  }
19948
19949  protected void composeSubscriptionChannelPayloadComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelPayloadComponent element, int index) {
19950    if (element == null) 
19951      return;
19952    Complex t;
19953    if (Utilities.noString(parentType))
19954      t = parent;
19955    else {
19956      t = parent.predicate("fhir:"+parentType+'.'+name);
19957    }
19958    composeBackboneElement(t, "payload", name, element, index);
19959    if (element.hasContentTypeElement()) {
19960      composeCode(t, "SubscriptionChannelPayloadComponent", "contentType", element.getContentTypeElement(), -1);
19961    }
19962    if (element.hasContentElement()) {
19963      composeEnum(t, "SubscriptionChannelPayloadComponent", "content", element.getContentElement(), -1);
19964    }
19965  }
19966
19967  protected void composeSubstance(Complex parent, String parentType, String name, Substance element, int index) {
19968    if (element == null) 
19969      return;
19970    Complex t;
19971    if (Utilities.noString(parentType))
19972      t = parent;
19973    else {
19974      t = parent.predicate("fhir:"+parentType+'.'+name);
19975    }
19976    composeDomainResource(t, "Substance", name, element, index);
19977    for (int i = 0; i < element.getIdentifier().size(); i++) {
19978      composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i);
19979    }
19980    if (element.hasStatusElement()) {
19981      composeEnum(t, "Substance", "status", element.getStatusElement(), -1);
19982    }
19983    for (int i = 0; i < element.getCategory().size(); i++) {
19984      composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i);
19985    }
19986    if (element.hasCode()) {
19987      composeCodeableConcept(t, "Substance", "code", element.getCode(), -1);
19988    }
19989    if (element.hasDescriptionElement()) {
19990      composeString(t, "Substance", "description", element.getDescriptionElement(), -1);
19991    }
19992    for (int i = 0; i < element.getInstance().size(); i++) {
19993      composeSubstanceInstanceComponent(t, "Substance", "instance", element.getInstance().get(i), i);
19994    }
19995    for (int i = 0; i < element.getIngredient().size(); i++) {
19996      composeSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i);
19997    }
19998  }
19999
20000  protected void composeSubstanceInstanceComponent(Complex parent, String parentType, String name, Substance.SubstanceInstanceComponent element, int index) {
20001    if (element == null) 
20002      return;
20003    Complex t;
20004    if (Utilities.noString(parentType))
20005      t = parent;
20006    else {
20007      t = parent.predicate("fhir:"+parentType+'.'+name);
20008    }
20009    composeBackboneElement(t, "instance", name, element, index);
20010    if (element.hasIdentifier()) {
20011      composeIdentifier(t, "SubstanceInstanceComponent", "identifier", element.getIdentifier(), -1);
20012    }
20013    if (element.hasExpiryElement()) {
20014      composeDateTime(t, "SubstanceInstanceComponent", "expiry", element.getExpiryElement(), -1);
20015    }
20016    if (element.hasQuantity()) {
20017      composeQuantity(t, "SubstanceInstanceComponent", "quantity", element.getQuantity(), -1);
20018    }
20019  }
20020
20021  protected void composeSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent element, int index) {
20022    if (element == null) 
20023      return;
20024    Complex t;
20025    if (Utilities.noString(parentType))
20026      t = parent;
20027    else {
20028      t = parent.predicate("fhir:"+parentType+'.'+name);
20029    }
20030    composeBackboneElement(t, "ingredient", name, element, index);
20031    if (element.hasQuantity()) {
20032      composeRatio(t, "SubstanceIngredientComponent", "quantity", element.getQuantity(), -1);
20033    }
20034    if (element.hasSubstance()) {
20035      composeType(t, "SubstanceIngredientComponent", "substance", element.getSubstance(), -1);
20036    }
20037  }
20038
20039  protected void composeSubstanceDefinition(Complex parent, String parentType, String name, SubstanceDefinition element, int index) {
20040    if (element == null) 
20041      return;
20042    Complex t;
20043    if (Utilities.noString(parentType))
20044      t = parent;
20045    else {
20046      t = parent.predicate("fhir:"+parentType+'.'+name);
20047    }
20048    composeDomainResource(t, "SubstanceDefinition", name, element, index);
20049    if (element.hasIdentifier()) {
20050      composeIdentifier(t, "SubstanceDefinition", "identifier", element.getIdentifier(), -1);
20051    }
20052    if (element.hasVersionElement()) {
20053      composeString(t, "SubstanceDefinition", "version", element.getVersionElement(), -1);
20054    }
20055    if (element.hasStatus()) {
20056      composeCodeableConcept(t, "SubstanceDefinition", "status", element.getStatus(), -1);
20057    }
20058    if (element.hasCategory()) {
20059      composeCodeableConcept(t, "SubstanceDefinition", "category", element.getCategory(), -1);
20060    }
20061    if (element.hasDomain()) {
20062      composeCodeableConcept(t, "SubstanceDefinition", "domain", element.getDomain(), -1);
20063    }
20064    if (element.hasDescriptionElement()) {
20065      composeMarkdown(t, "SubstanceDefinition", "description", element.getDescriptionElement(), -1);
20066    }
20067    for (int i = 0; i < element.getSource().size(); i++) {
20068      composeReference(t, "SubstanceDefinition", "source", element.getSource().get(i), i);
20069    }
20070    for (int i = 0; i < element.getNote().size(); i++) {
20071      composeAnnotation(t, "SubstanceDefinition", "note", element.getNote().get(i), i);
20072    }
20073    for (int i = 0; i < element.getManufacturer().size(); i++) {
20074      composeReference(t, "SubstanceDefinition", "manufacturer", element.getManufacturer().get(i), i);
20075    }
20076    for (int i = 0; i < element.getSupplier().size(); i++) {
20077      composeReference(t, "SubstanceDefinition", "supplier", element.getSupplier().get(i), i);
20078    }
20079    for (int i = 0; i < element.getMoiety().size(); i++) {
20080      composeSubstanceDefinitionMoietyComponent(t, "SubstanceDefinition", "moiety", element.getMoiety().get(i), i);
20081    }
20082    for (int i = 0; i < element.getProperty().size(); i++) {
20083      composeSubstanceDefinitionPropertyComponent(t, "SubstanceDefinition", "property", element.getProperty().get(i), i);
20084    }
20085    if (element.hasReferenceInformation()) {
20086      composeReference(t, "SubstanceDefinition", "referenceInformation", element.getReferenceInformation(), -1);
20087    }
20088    if (element.hasStructure()) {
20089      composeSubstanceDefinitionStructureComponent(t, "SubstanceDefinition", "structure", element.getStructure(), -1);
20090    }
20091    for (int i = 0; i < element.getCode().size(); i++) {
20092      composeSubstanceDefinitionCodeComponent(t, "SubstanceDefinition", "code", element.getCode().get(i), i);
20093    }
20094    for (int i = 0; i < element.getName().size(); i++) {
20095      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinition", "name", element.getName().get(i), i);
20096    }
20097    for (int i = 0; i < element.getMolecularWeight().size(); i++) {
20098      composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(t, "SubstanceDefinition", "molecularWeight", element.getMolecularWeight().get(i), i);
20099    }
20100    for (int i = 0; i < element.getRelationship().size(); i++) {
20101      composeSubstanceDefinitionRelationshipComponent(t, "SubstanceDefinition", "relationship", element.getRelationship().get(i), i);
20102    }
20103    if (element.hasNucleicAcid()) {
20104      composeReference(t, "SubstanceDefinition", "nucleicAcid", element.getNucleicAcid(), -1);
20105    }
20106    if (element.hasPolymer()) {
20107      composeReference(t, "SubstanceDefinition", "polymer", element.getPolymer(), -1);
20108    }
20109    if (element.hasProtein()) {
20110      composeReference(t, "SubstanceDefinition", "protein", element.getProtein(), -1);
20111    }
20112    if (element.hasSourceMaterial()) {
20113      composeReference(t, "SubstanceDefinition", "sourceMaterial", element.getSourceMaterial(), -1);
20114    }
20115  }
20116
20117  protected void composeSubstanceDefinitionMoietyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionMoietyComponent element, int index) {
20118    if (element == null) 
20119      return;
20120    Complex t;
20121    if (Utilities.noString(parentType))
20122      t = parent;
20123    else {
20124      t = parent.predicate("fhir:"+parentType+'.'+name);
20125    }
20126    composeBackboneElement(t, "moiety", name, element, index);
20127    if (element.hasRole()) {
20128      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "role", element.getRole(), -1);
20129    }
20130    if (element.hasIdentifier()) {
20131      composeIdentifier(t, "SubstanceDefinitionMoietyComponent", "identifier", element.getIdentifier(), -1);
20132    }
20133    if (element.hasNameElement()) {
20134      composeString(t, "SubstanceDefinitionMoietyComponent", "name", element.getNameElement(), -1);
20135    }
20136    if (element.hasStereochemistry()) {
20137      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "stereochemistry", element.getStereochemistry(), -1);
20138    }
20139    if (element.hasOpticalActivity()) {
20140      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "opticalActivity", element.getOpticalActivity(), -1);
20141    }
20142    if (element.hasMolecularFormulaElement()) {
20143      composeString(t, "SubstanceDefinitionMoietyComponent", "molecularFormula", element.getMolecularFormulaElement(), -1);
20144    }
20145    if (element.hasAmount()) {
20146      composeType(t, "SubstanceDefinitionMoietyComponent", "amount", element.getAmount(), -1);
20147    }
20148    if (element.hasAmountType()) {
20149      composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "amountType", element.getAmountType(), -1);
20150    }
20151  }
20152
20153  protected void composeSubstanceDefinitionPropertyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionPropertyComponent element, int index) {
20154    if (element == null) 
20155      return;
20156    Complex t;
20157    if (Utilities.noString(parentType))
20158      t = parent;
20159    else {
20160      t = parent.predicate("fhir:"+parentType+'.'+name);
20161    }
20162    composeBackboneElement(t, "property", name, element, index);
20163    if (element.hasCategory()) {
20164      composeCodeableConcept(t, "SubstanceDefinitionPropertyComponent", "category", element.getCategory(), -1);
20165    }
20166    if (element.hasCode()) {
20167      composeCodeableConcept(t, "SubstanceDefinitionPropertyComponent", "code", element.getCode(), -1);
20168    }
20169    if (element.hasParametersElement()) {
20170      composeString(t, "SubstanceDefinitionPropertyComponent", "parameters", element.getParametersElement(), -1);
20171    }
20172    if (element.hasDefiningSubstance()) {
20173      composeType(t, "SubstanceDefinitionPropertyComponent", "definingSubstance", element.getDefiningSubstance(), -1);
20174    }
20175    if (element.hasAmount()) {
20176      composeType(t, "SubstanceDefinitionPropertyComponent", "amount", element.getAmount(), -1);
20177    }
20178    if (element.hasReferenceRange()) {
20179      composeRange(t, "SubstanceDefinitionPropertyComponent", "referenceRange", element.getReferenceRange(), -1);
20180    }
20181    for (int i = 0; i < element.getSource().size(); i++) {
20182      composeReference(t, "SubstanceDefinitionPropertyComponent", "source", element.getSource().get(i), i);
20183    }
20184  }
20185
20186  protected void composeSubstanceDefinitionStructureComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureComponent element, int index) {
20187    if (element == null) 
20188      return;
20189    Complex t;
20190    if (Utilities.noString(parentType))
20191      t = parent;
20192    else {
20193      t = parent.predicate("fhir:"+parentType+'.'+name);
20194    }
20195    composeBackboneElement(t, "structure", name, element, index);
20196    if (element.hasStereochemistry()) {
20197      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "stereochemistry", element.getStereochemistry(), -1);
20198    }
20199    if (element.hasOpticalActivity()) {
20200      composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "opticalActivity", element.getOpticalActivity(), -1);
20201    }
20202    if (element.hasMolecularFormulaElement()) {
20203      composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormula", element.getMolecularFormulaElement(), -1);
20204    }
20205    if (element.hasMolecularFormulaByMoietyElement()) {
20206      composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormulaByMoiety", element.getMolecularFormulaByMoietyElement(), -1);
20207    }
20208    for (int i = 0; i < element.getIsotope().size(); i++) {
20209      composeSubstanceDefinitionStructureIsotopeComponent(t, "SubstanceDefinitionStructureComponent", "isotope", element.getIsotope().get(i), i);
20210    }
20211    if (element.hasMolecularWeight()) {
20212      composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(t, "SubstanceDefinitionStructureComponent", "molecularWeight", element.getMolecularWeight(), -1);
20213    }
20214    for (int i = 0; i < element.getSourceCoding().size(); i++) {
20215      composeCoding(t, "SubstanceDefinitionStructureComponent", "sourceCoding", element.getSourceCoding().get(i), i);
20216    }
20217    for (int i = 0; i < element.getSourceDocument().size(); i++) {
20218      composeReference(t, "SubstanceDefinitionStructureComponent", "sourceDocument", element.getSourceDocument().get(i), i);
20219    }
20220    for (int i = 0; i < element.getRepresentation().size(); i++) {
20221      composeSubstanceDefinitionStructureRepresentationComponent(t, "SubstanceDefinitionStructureComponent", "representation", element.getRepresentation().get(i), i);
20222    }
20223  }
20224
20225  protected void composeSubstanceDefinitionStructureIsotopeComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureIsotopeComponent element, int index) {
20226    if (element == null) 
20227      return;
20228    Complex t;
20229    if (Utilities.noString(parentType))
20230      t = parent;
20231    else {
20232      t = parent.predicate("fhir:"+parentType+'.'+name);
20233    }
20234    composeBackboneElement(t, "isotope", name, element, index);
20235    if (element.hasIdentifier()) {
20236      composeIdentifier(t, "SubstanceDefinitionStructureIsotopeComponent", "identifier", element.getIdentifier(), -1);
20237    }
20238    if (element.hasName()) {
20239      composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeComponent", "name", element.getName(), -1);
20240    }
20241    if (element.hasSubstitution()) {
20242      composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeComponent", "substitution", element.getSubstitution(), -1);
20243    }
20244    if (element.hasHalfLife()) {
20245      composeQuantity(t, "SubstanceDefinitionStructureIsotopeComponent", "halfLife", element.getHalfLife(), -1);
20246    }
20247    if (element.hasMolecularWeight()) {
20248      composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(t, "SubstanceDefinitionStructureIsotopeComponent", "molecularWeight", element.getMolecularWeight(), -1);
20249    }
20250  }
20251
20252  protected void composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureIsotopeMolecularWeightComponent element, int index) {
20253    if (element == null) 
20254      return;
20255    Complex t;
20256    if (Utilities.noString(parentType))
20257      t = parent;
20258    else {
20259      t = parent.predicate("fhir:"+parentType+'.'+name);
20260    }
20261    composeBackboneElement(t, "molecularWeight", name, element, index);
20262    if (element.hasMethod()) {
20263      composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeMolecularWeightComponent", "method", element.getMethod(), -1);
20264    }
20265    if (element.hasType()) {
20266      composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeMolecularWeightComponent", "type", element.getType(), -1);
20267    }
20268    if (element.hasAmount()) {
20269      composeQuantity(t, "SubstanceDefinitionStructureIsotopeMolecularWeightComponent", "amount", element.getAmount(), -1);
20270    }
20271  }
20272
20273  protected void composeSubstanceDefinitionStructureRepresentationComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureRepresentationComponent element, int index) {
20274    if (element == null) 
20275      return;
20276    Complex t;
20277    if (Utilities.noString(parentType))
20278      t = parent;
20279    else {
20280      t = parent.predicate("fhir:"+parentType+'.'+name);
20281    }
20282    composeBackboneElement(t, "representation", name, element, index);
20283    if (element.hasType()) {
20284      composeCodeableConcept(t, "SubstanceDefinitionStructureRepresentationComponent", "type", element.getType(), -1);
20285    }
20286    if (element.hasRepresentationElement()) {
20287      composeString(t, "SubstanceDefinitionStructureRepresentationComponent", "representation", element.getRepresentationElement(), -1);
20288    }
20289    if (element.hasAttachment()) {
20290      composeAttachment(t, "SubstanceDefinitionStructureRepresentationComponent", "attachment", element.getAttachment(), -1);
20291    }
20292  }
20293
20294  protected void composeSubstanceDefinitionCodeComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionCodeComponent element, int index) {
20295    if (element == null) 
20296      return;
20297    Complex t;
20298    if (Utilities.noString(parentType))
20299      t = parent;
20300    else {
20301      t = parent.predicate("fhir:"+parentType+'.'+name);
20302    }
20303    composeBackboneElement(t, "code", name, element, index);
20304    if (element.hasCode()) {
20305      composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "code", element.getCode(), -1);
20306    }
20307    if (element.hasStatus()) {
20308      composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "status", element.getStatus(), -1);
20309    }
20310    if (element.hasStatusDateElement()) {
20311      composeDateTime(t, "SubstanceDefinitionCodeComponent", "statusDate", element.getStatusDateElement(), -1);
20312    }
20313    for (int i = 0; i < element.getNote().size(); i++) {
20314      composeAnnotation(t, "SubstanceDefinitionCodeComponent", "note", element.getNote().get(i), i);
20315    }
20316    for (int i = 0; i < element.getSource().size(); i++) {
20317      composeReference(t, "SubstanceDefinitionCodeComponent", "source", element.getSource().get(i), i);
20318    }
20319  }
20320
20321  protected void composeSubstanceDefinitionNameComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameComponent element, int index) {
20322    if (element == null) 
20323      return;
20324    Complex t;
20325    if (Utilities.noString(parentType))
20326      t = parent;
20327    else {
20328      t = parent.predicate("fhir:"+parentType+'.'+name);
20329    }
20330    composeBackboneElement(t, "name", name, element, index);
20331    if (element.hasNameElement()) {
20332      composeString(t, "SubstanceDefinitionNameComponent", "name", element.getNameElement(), -1);
20333    }
20334    if (element.hasType()) {
20335      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "type", element.getType(), -1);
20336    }
20337    if (element.hasStatus()) {
20338      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "status", element.getStatus(), -1);
20339    }
20340    if (element.hasPreferredElement()) {
20341      composeBoolean(t, "SubstanceDefinitionNameComponent", "preferred", element.getPreferredElement(), -1);
20342    }
20343    for (int i = 0; i < element.getLanguage().size(); i++) {
20344      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "language", element.getLanguage().get(i), i);
20345    }
20346    for (int i = 0; i < element.getDomain().size(); i++) {
20347      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "domain", element.getDomain().get(i), i);
20348    }
20349    for (int i = 0; i < element.getJurisdiction().size(); i++) {
20350      composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "jurisdiction", element.getJurisdiction().get(i), i);
20351    }
20352    for (int i = 0; i < element.getSynonym().size(); i++) {
20353      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "synonym", element.getSynonym().get(i), i);
20354    }
20355    for (int i = 0; i < element.getTranslation().size(); i++) {
20356      composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "translation", element.getTranslation().get(i), i);
20357    }
20358    for (int i = 0; i < element.getOfficial().size(); i++) {
20359      composeSubstanceDefinitionNameOfficialComponent(t, "SubstanceDefinitionNameComponent", "official", element.getOfficial().get(i), i);
20360    }
20361    for (int i = 0; i < element.getSource().size(); i++) {
20362      composeReference(t, "SubstanceDefinitionNameComponent", "source", element.getSource().get(i), i);
20363    }
20364  }
20365
20366  protected void composeSubstanceDefinitionNameOfficialComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameOfficialComponent element, int index) {
20367    if (element == null) 
20368      return;
20369    Complex t;
20370    if (Utilities.noString(parentType))
20371      t = parent;
20372    else {
20373      t = parent.predicate("fhir:"+parentType+'.'+name);
20374    }
20375    composeBackboneElement(t, "official", name, element, index);
20376    if (element.hasAuthority()) {
20377      composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "authority", element.getAuthority(), -1);
20378    }
20379    if (element.hasStatus()) {
20380      composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "status", element.getStatus(), -1);
20381    }
20382    if (element.hasDateElement()) {
20383      composeDateTime(t, "SubstanceDefinitionNameOfficialComponent", "date", element.getDateElement(), -1);
20384    }
20385  }
20386
20387  protected void composeSubstanceDefinitionRelationshipComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionRelationshipComponent element, int index) {
20388    if (element == null) 
20389      return;
20390    Complex t;
20391    if (Utilities.noString(parentType))
20392      t = parent;
20393    else {
20394      t = parent.predicate("fhir:"+parentType+'.'+name);
20395    }
20396    composeBackboneElement(t, "relationship", name, element, index);
20397    if (element.hasSubstanceDefinition()) {
20398      composeType(t, "SubstanceDefinitionRelationshipComponent", "substanceDefinition", element.getSubstanceDefinition(), -1);
20399    }
20400    if (element.hasType()) {
20401      composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "type", element.getType(), -1);
20402    }
20403    if (element.hasIsDefiningElement()) {
20404      composeBoolean(t, "SubstanceDefinitionRelationshipComponent", "isDefining", element.getIsDefiningElement(), -1);
20405    }
20406    if (element.hasAmount()) {
20407      composeType(t, "SubstanceDefinitionRelationshipComponent", "amount", element.getAmount(), -1);
20408    }
20409    if (element.hasAmountRatioHighLimit()) {
20410      composeRatio(t, "SubstanceDefinitionRelationshipComponent", "amountRatioHighLimit", element.getAmountRatioHighLimit(), -1);
20411    }
20412    if (element.hasAmountType()) {
20413      composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "amountType", element.getAmountType(), -1);
20414    }
20415    for (int i = 0; i < element.getSource().size(); i++) {
20416      composeReference(t, "SubstanceDefinitionRelationshipComponent", "source", element.getSource().get(i), i);
20417    }
20418  }
20419
20420  protected void composeSubstanceNucleicAcid(Complex parent, String parentType, String name, SubstanceNucleicAcid element, int index) {
20421    if (element == null) 
20422      return;
20423    Complex t;
20424    if (Utilities.noString(parentType))
20425      t = parent;
20426    else {
20427      t = parent.predicate("fhir:"+parentType+'.'+name);
20428    }
20429    composeDomainResource(t, "SubstanceNucleicAcid", name, element, index);
20430    if (element.hasSequenceType()) {
20431      composeCodeableConcept(t, "SubstanceNucleicAcid", "sequenceType", element.getSequenceType(), -1);
20432    }
20433    if (element.hasNumberOfSubunitsElement()) {
20434      composeInteger(t, "SubstanceNucleicAcid", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1);
20435    }
20436    if (element.hasAreaOfHybridisationElement()) {
20437      composeString(t, "SubstanceNucleicAcid", "areaOfHybridisation", element.getAreaOfHybridisationElement(), -1);
20438    }
20439    if (element.hasOligoNucleotideType()) {
20440      composeCodeableConcept(t, "SubstanceNucleicAcid", "oligoNucleotideType", element.getOligoNucleotideType(), -1);
20441    }
20442    for (int i = 0; i < element.getSubunit().size(); i++) {
20443      composeSubstanceNucleicAcidSubunitComponent(t, "SubstanceNucleicAcid", "subunit", element.getSubunit().get(i), i);
20444    }
20445  }
20446
20447  protected void composeSubstanceNucleicAcidSubunitComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitComponent element, int index) {
20448    if (element == null) 
20449      return;
20450    Complex t;
20451    if (Utilities.noString(parentType))
20452      t = parent;
20453    else {
20454      t = parent.predicate("fhir:"+parentType+'.'+name);
20455    }
20456    composeBackboneElement(t, "subunit", name, element, index);
20457    if (element.hasSubunitElement()) {
20458      composeInteger(t, "SubstanceNucleicAcidSubunitComponent", "subunit", element.getSubunitElement(), -1);
20459    }
20460    if (element.hasSequenceElement()) {
20461      composeString(t, "SubstanceNucleicAcidSubunitComponent", "sequence", element.getSequenceElement(), -1);
20462    }
20463    if (element.hasLengthElement()) {
20464      composeInteger(t, "SubstanceNucleicAcidSubunitComponent", "length", element.getLengthElement(), -1);
20465    }
20466    if (element.hasSequenceAttachment()) {
20467      composeAttachment(t, "SubstanceNucleicAcidSubunitComponent", "sequenceAttachment", element.getSequenceAttachment(), -1);
20468    }
20469    if (element.hasFivePrime()) {
20470      composeCodeableConcept(t, "SubstanceNucleicAcidSubunitComponent", "fivePrime", element.getFivePrime(), -1);
20471    }
20472    if (element.hasThreePrime()) {
20473      composeCodeableConcept(t, "SubstanceNucleicAcidSubunitComponent", "threePrime", element.getThreePrime(), -1);
20474    }
20475    for (int i = 0; i < element.getLinkage().size(); i++) {
20476      composeSubstanceNucleicAcidSubunitLinkageComponent(t, "SubstanceNucleicAcidSubunitComponent", "linkage", element.getLinkage().get(i), i);
20477    }
20478    for (int i = 0; i < element.getSugar().size(); i++) {
20479      composeSubstanceNucleicAcidSubunitSugarComponent(t, "SubstanceNucleicAcidSubunitComponent", "sugar", element.getSugar().get(i), i);
20480    }
20481  }
20482
20483  protected void composeSubstanceNucleicAcidSubunitLinkageComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitLinkageComponent element, int index) {
20484    if (element == null) 
20485      return;
20486    Complex t;
20487    if (Utilities.noString(parentType))
20488      t = parent;
20489    else {
20490      t = parent.predicate("fhir:"+parentType+'.'+name);
20491    }
20492    composeBackboneElement(t, "linkage", name, element, index);
20493    if (element.hasConnectivityElement()) {
20494      composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "connectivity", element.getConnectivityElement(), -1);
20495    }
20496    if (element.hasIdentifier()) {
20497      composeIdentifier(t, "SubstanceNucleicAcidSubunitLinkageComponent", "identifier", element.getIdentifier(), -1);
20498    }
20499    if (element.hasNameElement()) {
20500      composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "name", element.getNameElement(), -1);
20501    }
20502    if (element.hasResidueSiteElement()) {
20503      composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "residueSite", element.getResidueSiteElement(), -1);
20504    }
20505  }
20506
20507  protected void composeSubstanceNucleicAcidSubunitSugarComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitSugarComponent element, int index) {
20508    if (element == null) 
20509      return;
20510    Complex t;
20511    if (Utilities.noString(parentType))
20512      t = parent;
20513    else {
20514      t = parent.predicate("fhir:"+parentType+'.'+name);
20515    }
20516    composeBackboneElement(t, "sugar", name, element, index);
20517    if (element.hasIdentifier()) {
20518      composeIdentifier(t, "SubstanceNucleicAcidSubunitSugarComponent", "identifier", element.getIdentifier(), -1);
20519    }
20520    if (element.hasNameElement()) {
20521      composeString(t, "SubstanceNucleicAcidSubunitSugarComponent", "name", element.getNameElement(), -1);
20522    }
20523    if (element.hasResidueSiteElement()) {
20524      composeString(t, "SubstanceNucleicAcidSubunitSugarComponent", "residueSite", element.getResidueSiteElement(), -1);
20525    }
20526  }
20527
20528  protected void composeSubstancePolymer(Complex parent, String parentType, String name, SubstancePolymer element, int index) {
20529    if (element == null) 
20530      return;
20531    Complex t;
20532    if (Utilities.noString(parentType))
20533      t = parent;
20534    else {
20535      t = parent.predicate("fhir:"+parentType+'.'+name);
20536    }
20537    composeDomainResource(t, "SubstancePolymer", name, element, index);
20538    if (element.hasClass_()) {
20539      composeCodeableConcept(t, "SubstancePolymer", "class", element.getClass_(), -1);
20540    }
20541    if (element.hasGeometry()) {
20542      composeCodeableConcept(t, "SubstancePolymer", "geometry", element.getGeometry(), -1);
20543    }
20544    for (int i = 0; i < element.getCopolymerConnectivity().size(); i++) {
20545      composeCodeableConcept(t, "SubstancePolymer", "copolymerConnectivity", element.getCopolymerConnectivity().get(i), i);
20546    }
20547    for (int i = 0; i < element.getModification().size(); i++) {
20548      composeString(t, "SubstancePolymer", "modification", element.getModification().get(i), i);
20549    }
20550    for (int i = 0; i < element.getMonomerSet().size(); i++) {
20551      composeSubstancePolymerMonomerSetComponent(t, "SubstancePolymer", "monomerSet", element.getMonomerSet().get(i), i);
20552    }
20553    for (int i = 0; i < element.getRepeat().size(); i++) {
20554      composeSubstancePolymerRepeatComponent(t, "SubstancePolymer", "repeat", element.getRepeat().get(i), i);
20555    }
20556  }
20557
20558  protected void composeSubstancePolymerMonomerSetComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetComponent 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, "monomerSet", name, element, index);
20568    if (element.hasRatioType()) {
20569      composeCodeableConcept(t, "SubstancePolymerMonomerSetComponent", "ratioType", element.getRatioType(), -1);
20570    }
20571    for (int i = 0; i < element.getStartingMaterial().size(); i++) {
20572      composeSubstancePolymerMonomerSetStartingMaterialComponent(t, "SubstancePolymerMonomerSetComponent", "startingMaterial", element.getStartingMaterial().get(i), i);
20573    }
20574  }
20575
20576  protected void composeSubstancePolymerMonomerSetStartingMaterialComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetStartingMaterialComponent element, int index) {
20577    if (element == null) 
20578      return;
20579    Complex t;
20580    if (Utilities.noString(parentType))
20581      t = parent;
20582    else {
20583      t = parent.predicate("fhir:"+parentType+'.'+name);
20584    }
20585    composeBackboneElement(t, "startingMaterial", name, element, index);
20586    if (element.hasMaterial()) {
20587      composeCodeableConcept(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "material", element.getMaterial(), -1);
20588    }
20589    if (element.hasType()) {
20590      composeCodeableConcept(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "type", element.getType(), -1);
20591    }
20592    if (element.hasIsDefiningElement()) {
20593      composeBoolean(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "isDefining", element.getIsDefiningElement(), -1);
20594    }
20595    if (element.hasAmount()) {
20596      composeSubstanceAmount(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "amount", element.getAmount(), -1);
20597    }
20598  }
20599
20600  protected void composeSubstancePolymerRepeatComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatComponent element, int index) {
20601    if (element == null) 
20602      return;
20603    Complex t;
20604    if (Utilities.noString(parentType))
20605      t = parent;
20606    else {
20607      t = parent.predicate("fhir:"+parentType+'.'+name);
20608    }
20609    composeBackboneElement(t, "repeat", name, element, index);
20610    if (element.hasNumberOfUnitsElement()) {
20611      composeInteger(t, "SubstancePolymerRepeatComponent", "numberOfUnits", element.getNumberOfUnitsElement(), -1);
20612    }
20613    if (element.hasAverageMolecularFormulaElement()) {
20614      composeString(t, "SubstancePolymerRepeatComponent", "averageMolecularFormula", element.getAverageMolecularFormulaElement(), -1);
20615    }
20616    if (element.hasRepeatUnitAmountType()) {
20617      composeCodeableConcept(t, "SubstancePolymerRepeatComponent", "repeatUnitAmountType", element.getRepeatUnitAmountType(), -1);
20618    }
20619    for (int i = 0; i < element.getRepeatUnit().size(); i++) {
20620      composeSubstancePolymerRepeatRepeatUnitComponent(t, "SubstancePolymerRepeatComponent", "repeatUnit", element.getRepeatUnit().get(i), i);
20621    }
20622  }
20623
20624  protected void composeSubstancePolymerRepeatRepeatUnitComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitComponent element, int index) {
20625    if (element == null) 
20626      return;
20627    Complex t;
20628    if (Utilities.noString(parentType))
20629      t = parent;
20630    else {
20631      t = parent.predicate("fhir:"+parentType+'.'+name);
20632    }
20633    composeBackboneElement(t, "repeatUnit", name, element, index);
20634    if (element.hasOrientationOfPolymerisation()) {
20635      composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitComponent", "orientationOfPolymerisation", element.getOrientationOfPolymerisation(), -1);
20636    }
20637    if (element.hasRepeatUnitElement()) {
20638      composeString(t, "SubstancePolymerRepeatRepeatUnitComponent", "repeatUnit", element.getRepeatUnitElement(), -1);
20639    }
20640    if (element.hasAmount()) {
20641      composeSubstanceAmount(t, "SubstancePolymerRepeatRepeatUnitComponent", "amount", element.getAmount(), -1);
20642    }
20643    for (int i = 0; i < element.getDegreeOfPolymerisation().size(); i++) {
20644      composeSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(t, "SubstancePolymerRepeatRepeatUnitComponent", "degreeOfPolymerisation", element.getDegreeOfPolymerisation().get(i), i);
20645    }
20646    for (int i = 0; i < element.getStructuralRepresentation().size(); i++) {
20647      composeSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(t, "SubstancePolymerRepeatRepeatUnitComponent", "structuralRepresentation", element.getStructuralRepresentation().get(i), i);
20648    }
20649  }
20650
20651  protected void composeSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent element, int index) {
20652    if (element == null) 
20653      return;
20654    Complex t;
20655    if (Utilities.noString(parentType))
20656      t = parent;
20657    else {
20658      t = parent.predicate("fhir:"+parentType+'.'+name);
20659    }
20660    composeBackboneElement(t, "degreeOfPolymerisation", name, element, index);
20661    if (element.hasDegree()) {
20662      composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "degree", element.getDegree(), -1);
20663    }
20664    if (element.hasAmount()) {
20665      composeSubstanceAmount(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "amount", element.getAmount(), -1);
20666    }
20667  }
20668
20669  protected void composeSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent element, int index) {
20670    if (element == null) 
20671      return;
20672    Complex t;
20673    if (Utilities.noString(parentType))
20674      t = parent;
20675    else {
20676      t = parent.predicate("fhir:"+parentType+'.'+name);
20677    }
20678    composeBackboneElement(t, "structuralRepresentation", name, element, index);
20679    if (element.hasType()) {
20680      composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "type", element.getType(), -1);
20681    }
20682    if (element.hasRepresentationElement()) {
20683      composeString(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "representation", element.getRepresentationElement(), -1);
20684    }
20685    if (element.hasAttachment()) {
20686      composeAttachment(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "attachment", element.getAttachment(), -1);
20687    }
20688  }
20689
20690  protected void composeSubstanceProtein(Complex parent, String parentType, String name, SubstanceProtein element, int index) {
20691    if (element == null) 
20692      return;
20693    Complex t;
20694    if (Utilities.noString(parentType))
20695      t = parent;
20696    else {
20697      t = parent.predicate("fhir:"+parentType+'.'+name);
20698    }
20699    composeDomainResource(t, "SubstanceProtein", name, element, index);
20700    if (element.hasSequenceType()) {
20701      composeCodeableConcept(t, "SubstanceProtein", "sequenceType", element.getSequenceType(), -1);
20702    }
20703    if (element.hasNumberOfSubunitsElement()) {
20704      composeInteger(t, "SubstanceProtein", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1);
20705    }
20706    for (int i = 0; i < element.getDisulfideLinkage().size(); i++) {
20707      composeString(t, "SubstanceProtein", "disulfideLinkage", element.getDisulfideLinkage().get(i), i);
20708    }
20709    for (int i = 0; i < element.getSubunit().size(); i++) {
20710      composeSubstanceProteinSubunitComponent(t, "SubstanceProtein", "subunit", element.getSubunit().get(i), i);
20711    }
20712  }
20713
20714  protected void composeSubstanceProteinSubunitComponent(Complex parent, String parentType, String name, SubstanceProtein.SubstanceProteinSubunitComponent element, int index) {
20715    if (element == null) 
20716      return;
20717    Complex t;
20718    if (Utilities.noString(parentType))
20719      t = parent;
20720    else {
20721      t = parent.predicate("fhir:"+parentType+'.'+name);
20722    }
20723    composeBackboneElement(t, "subunit", name, element, index);
20724    if (element.hasSubunitElement()) {
20725      composeInteger(t, "SubstanceProteinSubunitComponent", "subunit", element.getSubunitElement(), -1);
20726    }
20727    if (element.hasSequenceElement()) {
20728      composeString(t, "SubstanceProteinSubunitComponent", "sequence", element.getSequenceElement(), -1);
20729    }
20730    if (element.hasLengthElement()) {
20731      composeInteger(t, "SubstanceProteinSubunitComponent", "length", element.getLengthElement(), -1);
20732    }
20733    if (element.hasSequenceAttachment()) {
20734      composeAttachment(t, "SubstanceProteinSubunitComponent", "sequenceAttachment", element.getSequenceAttachment(), -1);
20735    }
20736    if (element.hasNTerminalModificationId()) {
20737      composeIdentifier(t, "SubstanceProteinSubunitComponent", "nTerminalModificationId", element.getNTerminalModificationId(), -1);
20738    }
20739    if (element.hasNTerminalModificationElement()) {
20740      composeString(t, "SubstanceProteinSubunitComponent", "nTerminalModification", element.getNTerminalModificationElement(), -1);
20741    }
20742    if (element.hasCTerminalModificationId()) {
20743      composeIdentifier(t, "SubstanceProteinSubunitComponent", "cTerminalModificationId", element.getCTerminalModificationId(), -1);
20744    }
20745    if (element.hasCTerminalModificationElement()) {
20746      composeString(t, "SubstanceProteinSubunitComponent", "cTerminalModification", element.getCTerminalModificationElement(), -1);
20747    }
20748  }
20749
20750  protected void composeSubstanceReferenceInformation(Complex parent, String parentType, String name, SubstanceReferenceInformation element, int index) {
20751    if (element == null) 
20752      return;
20753    Complex t;
20754    if (Utilities.noString(parentType))
20755      t = parent;
20756    else {
20757      t = parent.predicate("fhir:"+parentType+'.'+name);
20758    }
20759    composeDomainResource(t, "SubstanceReferenceInformation", name, element, index);
20760    if (element.hasCommentElement()) {
20761      composeString(t, "SubstanceReferenceInformation", "comment", element.getCommentElement(), -1);
20762    }
20763    for (int i = 0; i < element.getGene().size(); i++) {
20764      composeSubstanceReferenceInformationGeneComponent(t, "SubstanceReferenceInformation", "gene", element.getGene().get(i), i);
20765    }
20766    for (int i = 0; i < element.getGeneElement().size(); i++) {
20767      composeSubstanceReferenceInformationGeneElementComponent(t, "SubstanceReferenceInformation", "geneElement", element.getGeneElement().get(i), i);
20768    }
20769    for (int i = 0; i < element.getClassification().size(); i++) {
20770      composeSubstanceReferenceInformationClassificationComponent(t, "SubstanceReferenceInformation", "classification", element.getClassification().get(i), i);
20771    }
20772    for (int i = 0; i < element.getTarget().size(); i++) {
20773      composeSubstanceReferenceInformationTargetComponent(t, "SubstanceReferenceInformation", "target", element.getTarget().get(i), i);
20774    }
20775  }
20776
20777  protected void composeSubstanceReferenceInformationGeneComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneComponent 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, "gene", name, element, index);
20787    if (element.hasGeneSequenceOrigin()) {
20788      composeCodeableConcept(t, "SubstanceReferenceInformationGeneComponent", "geneSequenceOrigin", element.getGeneSequenceOrigin(), -1);
20789    }
20790    if (element.hasGene()) {
20791      composeCodeableConcept(t, "SubstanceReferenceInformationGeneComponent", "gene", element.getGene(), -1);
20792    }
20793    for (int i = 0; i < element.getSource().size(); i++) {
20794      composeReference(t, "SubstanceReferenceInformationGeneComponent", "source", element.getSource().get(i), i);
20795    }
20796  }
20797
20798  protected void composeSubstanceReferenceInformationGeneElementComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneElementComponent element, int index) {
20799    if (element == null) 
20800      return;
20801    Complex t;
20802    if (Utilities.noString(parentType))
20803      t = parent;
20804    else {
20805      t = parent.predicate("fhir:"+parentType+'.'+name);
20806    }
20807    composeBackboneElement(t, "geneElement", name, element, index);
20808    if (element.hasType()) {
20809      composeCodeableConcept(t, "SubstanceReferenceInformationGeneElementComponent", "type", element.getType(), -1);
20810    }
20811    if (element.hasElement()) {
20812      composeIdentifier(t, "SubstanceReferenceInformationGeneElementComponent", "element", element.getElement(), -1);
20813    }
20814    for (int i = 0; i < element.getSource().size(); i++) {
20815      composeReference(t, "SubstanceReferenceInformationGeneElementComponent", "source", element.getSource().get(i), i);
20816    }
20817  }
20818
20819  protected void composeSubstanceReferenceInformationClassificationComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationClassificationComponent element, int index) {
20820    if (element == null) 
20821      return;
20822    Complex t;
20823    if (Utilities.noString(parentType))
20824      t = parent;
20825    else {
20826      t = parent.predicate("fhir:"+parentType+'.'+name);
20827    }
20828    composeBackboneElement(t, "classification", name, element, index);
20829    if (element.hasDomain()) {
20830      composeCodeableConcept(t, "SubstanceReferenceInformationClassificationComponent", "domain", element.getDomain(), -1);
20831    }
20832    if (element.hasClassification()) {
20833      composeCodeableConcept(t, "SubstanceReferenceInformationClassificationComponent", "classification", element.getClassification(), -1);
20834    }
20835    for (int i = 0; i < element.getSubtype().size(); i++) {
20836      composeCodeableConcept(t, "SubstanceReferenceInformationClassificationComponent", "subtype", element.getSubtype().get(i), i);
20837    }
20838    for (int i = 0; i < element.getSource().size(); i++) {
20839      composeReference(t, "SubstanceReferenceInformationClassificationComponent", "source", element.getSource().get(i), i);
20840    }
20841  }
20842
20843  protected void composeSubstanceReferenceInformationTargetComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationTargetComponent element, int index) {
20844    if (element == null) 
20845      return;
20846    Complex t;
20847    if (Utilities.noString(parentType))
20848      t = parent;
20849    else {
20850      t = parent.predicate("fhir:"+parentType+'.'+name);
20851    }
20852    composeBackboneElement(t, "target", name, element, index);
20853    if (element.hasTarget()) {
20854      composeIdentifier(t, "SubstanceReferenceInformationTargetComponent", "target", element.getTarget(), -1);
20855    }
20856    if (element.hasType()) {
20857      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "type", element.getType(), -1);
20858    }
20859    if (element.hasInteraction()) {
20860      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "interaction", element.getInteraction(), -1);
20861    }
20862    if (element.hasOrganism()) {
20863      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "organism", element.getOrganism(), -1);
20864    }
20865    if (element.hasOrganismType()) {
20866      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "organismType", element.getOrganismType(), -1);
20867    }
20868    if (element.hasAmount()) {
20869      composeType(t, "SubstanceReferenceInformationTargetComponent", "amount", element.getAmount(), -1);
20870    }
20871    if (element.hasAmountType()) {
20872      composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "amountType", element.getAmountType(), -1);
20873    }
20874    for (int i = 0; i < element.getSource().size(); i++) {
20875      composeReference(t, "SubstanceReferenceInformationTargetComponent", "source", element.getSource().get(i), i);
20876    }
20877  }
20878
20879  protected void composeSubstanceSourceMaterial(Complex parent, String parentType, String name, SubstanceSourceMaterial element, int index) {
20880    if (element == null) 
20881      return;
20882    Complex t;
20883    if (Utilities.noString(parentType))
20884      t = parent;
20885    else {
20886      t = parent.predicate("fhir:"+parentType+'.'+name);
20887    }
20888    composeDomainResource(t, "SubstanceSourceMaterial", name, element, index);
20889    if (element.hasSourceMaterialClass()) {
20890      composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialClass", element.getSourceMaterialClass(), -1);
20891    }
20892    if (element.hasSourceMaterialType()) {
20893      composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialType", element.getSourceMaterialType(), -1);
20894    }
20895    if (element.hasSourceMaterialState()) {
20896      composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialState", element.getSourceMaterialState(), -1);
20897    }
20898    if (element.hasOrganismId()) {
20899      composeIdentifier(t, "SubstanceSourceMaterial", "organismId", element.getOrganismId(), -1);
20900    }
20901    if (element.hasOrganismNameElement()) {
20902      composeString(t, "SubstanceSourceMaterial", "organismName", element.getOrganismNameElement(), -1);
20903    }
20904    for (int i = 0; i < element.getParentSubstanceId().size(); i++) {
20905      composeIdentifier(t, "SubstanceSourceMaterial", "parentSubstanceId", element.getParentSubstanceId().get(i), i);
20906    }
20907    for (int i = 0; i < element.getParentSubstanceName().size(); i++) {
20908      composeString(t, "SubstanceSourceMaterial", "parentSubstanceName", element.getParentSubstanceName().get(i), i);
20909    }
20910    for (int i = 0; i < element.getCountryOfOrigin().size(); i++) {
20911      composeCodeableConcept(t, "SubstanceSourceMaterial", "countryOfOrigin", element.getCountryOfOrigin().get(i), i);
20912    }
20913    for (int i = 0; i < element.getGeographicalLocation().size(); i++) {
20914      composeString(t, "SubstanceSourceMaterial", "geographicalLocation", element.getGeographicalLocation().get(i), i);
20915    }
20916    if (element.hasDevelopmentStage()) {
20917      composeCodeableConcept(t, "SubstanceSourceMaterial", "developmentStage", element.getDevelopmentStage(), -1);
20918    }
20919    for (int i = 0; i < element.getFractionDescription().size(); i++) {
20920      composeSubstanceSourceMaterialFractionDescriptionComponent(t, "SubstanceSourceMaterial", "fractionDescription", element.getFractionDescription().get(i), i);
20921    }
20922    if (element.hasOrganism()) {
20923      composeSubstanceSourceMaterialOrganismComponent(t, "SubstanceSourceMaterial", "organism", element.getOrganism(), -1);
20924    }
20925    for (int i = 0; i < element.getPartDescription().size(); i++) {
20926      composeSubstanceSourceMaterialPartDescriptionComponent(t, "SubstanceSourceMaterial", "partDescription", element.getPartDescription().get(i), i);
20927    }
20928  }
20929
20930  protected void composeSubstanceSourceMaterialFractionDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialFractionDescriptionComponent element, int index) {
20931    if (element == null) 
20932      return;
20933    Complex t;
20934    if (Utilities.noString(parentType))
20935      t = parent;
20936    else {
20937      t = parent.predicate("fhir:"+parentType+'.'+name);
20938    }
20939    composeBackboneElement(t, "fractionDescription", name, element, index);
20940    if (element.hasFractionElement()) {
20941      composeString(t, "SubstanceSourceMaterialFractionDescriptionComponent", "fraction", element.getFractionElement(), -1);
20942    }
20943    if (element.hasMaterialType()) {
20944      composeCodeableConcept(t, "SubstanceSourceMaterialFractionDescriptionComponent", "materialType", element.getMaterialType(), -1);
20945    }
20946  }
20947
20948  protected void composeSubstanceSourceMaterialOrganismComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismComponent element, int index) {
20949    if (element == null) 
20950      return;
20951    Complex t;
20952    if (Utilities.noString(parentType))
20953      t = parent;
20954    else {
20955      t = parent.predicate("fhir:"+parentType+'.'+name);
20956    }
20957    composeBackboneElement(t, "organism", name, element, index);
20958    if (element.hasFamily()) {
20959      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "family", element.getFamily(), -1);
20960    }
20961    if (element.hasGenus()) {
20962      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "genus", element.getGenus(), -1);
20963    }
20964    if (element.hasSpecies()) {
20965      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "species", element.getSpecies(), -1);
20966    }
20967    if (element.hasIntraspecificType()) {
20968      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "intraspecificType", element.getIntraspecificType(), -1);
20969    }
20970    if (element.hasIntraspecificDescriptionElement()) {
20971      composeString(t, "SubstanceSourceMaterialOrganismComponent", "intraspecificDescription", element.getIntraspecificDescriptionElement(), -1);
20972    }
20973    for (int i = 0; i < element.getAuthor().size(); i++) {
20974      composeSubstanceSourceMaterialOrganismAuthorComponent(t, "SubstanceSourceMaterialOrganismComponent", "author", element.getAuthor().get(i), i);
20975    }
20976    if (element.hasHybrid()) {
20977      composeSubstanceSourceMaterialOrganismHybridComponent(t, "SubstanceSourceMaterialOrganismComponent", "hybrid", element.getHybrid(), -1);
20978    }
20979    if (element.hasOrganismGeneral()) {
20980      composeSubstanceSourceMaterialOrganismOrganismGeneralComponent(t, "SubstanceSourceMaterialOrganismComponent", "organismGeneral", element.getOrganismGeneral(), -1);
20981    }
20982  }
20983
20984  protected void composeSubstanceSourceMaterialOrganismAuthorComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismAuthorComponent element, int index) {
20985    if (element == null) 
20986      return;
20987    Complex t;
20988    if (Utilities.noString(parentType))
20989      t = parent;
20990    else {
20991      t = parent.predicate("fhir:"+parentType+'.'+name);
20992    }
20993    composeBackboneElement(t, "author", name, element, index);
20994    if (element.hasAuthorType()) {
20995      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismAuthorComponent", "authorType", element.getAuthorType(), -1);
20996    }
20997    if (element.hasAuthorDescriptionElement()) {
20998      composeString(t, "SubstanceSourceMaterialOrganismAuthorComponent", "authorDescription", element.getAuthorDescriptionElement(), -1);
20999    }
21000  }
21001
21002  protected void composeSubstanceSourceMaterialOrganismHybridComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismHybridComponent element, int index) {
21003    if (element == null) 
21004      return;
21005    Complex t;
21006    if (Utilities.noString(parentType))
21007      t = parent;
21008    else {
21009      t = parent.predicate("fhir:"+parentType+'.'+name);
21010    }
21011    composeBackboneElement(t, "hybrid", name, element, index);
21012    if (element.hasMaternalOrganismIdElement()) {
21013      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "maternalOrganismId", element.getMaternalOrganismIdElement(), -1);
21014    }
21015    if (element.hasMaternalOrganismNameElement()) {
21016      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "maternalOrganismName", element.getMaternalOrganismNameElement(), -1);
21017    }
21018    if (element.hasPaternalOrganismIdElement()) {
21019      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "paternalOrganismId", element.getPaternalOrganismIdElement(), -1);
21020    }
21021    if (element.hasPaternalOrganismNameElement()) {
21022      composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "paternalOrganismName", element.getPaternalOrganismNameElement(), -1);
21023    }
21024    if (element.hasHybridType()) {
21025      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismHybridComponent", "hybridType", element.getHybridType(), -1);
21026    }
21027  }
21028
21029  protected void composeSubstanceSourceMaterialOrganismOrganismGeneralComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismOrganismGeneralComponent element, int index) {
21030    if (element == null) 
21031      return;
21032    Complex t;
21033    if (Utilities.noString(parentType))
21034      t = parent;
21035    else {
21036      t = parent.predicate("fhir:"+parentType+'.'+name);
21037    }
21038    composeBackboneElement(t, "organismGeneral", name, element, index);
21039    if (element.hasKingdom()) {
21040      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "kingdom", element.getKingdom(), -1);
21041    }
21042    if (element.hasPhylum()) {
21043      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "phylum", element.getPhylum(), -1);
21044    }
21045    if (element.hasClass_()) {
21046      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "class", element.getClass_(), -1);
21047    }
21048    if (element.hasOrder()) {
21049      composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "order", element.getOrder(), -1);
21050    }
21051  }
21052
21053  protected void composeSubstanceSourceMaterialPartDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialPartDescriptionComponent element, int index) {
21054    if (element == null) 
21055      return;
21056    Complex t;
21057    if (Utilities.noString(parentType))
21058      t = parent;
21059    else {
21060      t = parent.predicate("fhir:"+parentType+'.'+name);
21061    }
21062    composeBackboneElement(t, "partDescription", name, element, index);
21063    if (element.hasPart()) {
21064      composeCodeableConcept(t, "SubstanceSourceMaterialPartDescriptionComponent", "part", element.getPart(), -1);
21065    }
21066    if (element.hasPartLocation()) {
21067      composeCodeableConcept(t, "SubstanceSourceMaterialPartDescriptionComponent", "partLocation", element.getPartLocation(), -1);
21068    }
21069  }
21070
21071  protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery element, int index) {
21072    if (element == null) 
21073      return;
21074    Complex t;
21075    if (Utilities.noString(parentType))
21076      t = parent;
21077    else {
21078      t = parent.predicate("fhir:"+parentType+'.'+name);
21079    }
21080    composeDomainResource(t, "SupplyDelivery", name, element, index);
21081    for (int i = 0; i < element.getIdentifier().size(); i++) {
21082      composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier().get(i), i);
21083    }
21084    for (int i = 0; i < element.getBasedOn().size(); i++) {
21085      composeReference(t, "SupplyDelivery", "basedOn", element.getBasedOn().get(i), i);
21086    }
21087    for (int i = 0; i < element.getPartOf().size(); i++) {
21088      composeReference(t, "SupplyDelivery", "partOf", element.getPartOf().get(i), i);
21089    }
21090    if (element.hasStatusElement()) {
21091      composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1);
21092    }
21093    if (element.hasPatient()) {
21094      composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1);
21095    }
21096    if (element.hasType()) {
21097      composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1);
21098    }
21099    if (element.hasSuppliedItem()) {
21100      composeSupplyDeliverySuppliedItemComponent(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem(), -1);
21101    }
21102    if (element.hasOccurrence()) {
21103      composeType(t, "SupplyDelivery", "occurrence", element.getOccurrence(), -1);
21104    }
21105    if (element.hasSupplier()) {
21106      composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1);
21107    }
21108    if (element.hasDestination()) {
21109      composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1);
21110    }
21111    for (int i = 0; i < element.getReceiver().size(); i++) {
21112      composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i);
21113    }
21114  }
21115
21116  protected void composeSupplyDeliverySuppliedItemComponent(Complex parent, String parentType, String name, SupplyDelivery.SupplyDeliverySuppliedItemComponent element, int index) {
21117    if (element == null) 
21118      return;
21119    Complex t;
21120    if (Utilities.noString(parentType))
21121      t = parent;
21122    else {
21123      t = parent.predicate("fhir:"+parentType+'.'+name);
21124    }
21125    composeBackboneElement(t, "suppliedItem", name, element, index);
21126    if (element.hasQuantity()) {
21127      composeQuantity(t, "SupplyDeliverySuppliedItemComponent", "quantity", element.getQuantity(), -1);
21128    }
21129    if (element.hasItem()) {
21130      composeType(t, "SupplyDeliverySuppliedItemComponent", "item", element.getItem(), -1);
21131    }
21132  }
21133
21134  protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest element, int index) {
21135    if (element == null) 
21136      return;
21137    Complex t;
21138    if (Utilities.noString(parentType))
21139      t = parent;
21140    else {
21141      t = parent.predicate("fhir:"+parentType+'.'+name);
21142    }
21143    composeDomainResource(t, "SupplyRequest", name, element, index);
21144    for (int i = 0; i < element.getIdentifier().size(); i++) {
21145      composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier().get(i), i);
21146    }
21147    if (element.hasStatusElement()) {
21148      composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1);
21149    }
21150    if (element.hasCategory()) {
21151      composeCodeableConcept(t, "SupplyRequest", "category", element.getCategory(), -1);
21152    }
21153    if (element.hasPriorityElement()) {
21154      composeEnum(t, "SupplyRequest", "priority", element.getPriorityElement(), -1);
21155    }
21156    if (element.hasItem()) {
21157      composeType(t, "SupplyRequest", "item", element.getItem(), -1);
21158    }
21159    if (element.hasQuantity()) {
21160      composeQuantity(t, "SupplyRequest", "quantity", element.getQuantity(), -1);
21161    }
21162    for (int i = 0; i < element.getParameter().size(); i++) {
21163      composeSupplyRequestParameterComponent(t, "SupplyRequest", "parameter", element.getParameter().get(i), i);
21164    }
21165    if (element.hasOccurrence()) {
21166      composeType(t, "SupplyRequest", "occurrence", element.getOccurrence(), -1);
21167    }
21168    if (element.hasAuthoredOnElement()) {
21169      composeDateTime(t, "SupplyRequest", "authoredOn", element.getAuthoredOnElement(), -1);
21170    }
21171    if (element.hasRequester()) {
21172      composeReference(t, "SupplyRequest", "requester", element.getRequester(), -1);
21173    }
21174    for (int i = 0; i < element.getSupplier().size(); i++) {
21175      composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i);
21176    }
21177    for (int i = 0; i < element.getReason().size(); i++) {
21178      composeCodeableReference(t, "SupplyRequest", "reason", element.getReason().get(i), i);
21179    }
21180    if (element.hasDeliverFrom()) {
21181      composeReference(t, "SupplyRequest", "deliverFrom", element.getDeliverFrom(), -1);
21182    }
21183    if (element.hasDeliverTo()) {
21184      composeReference(t, "SupplyRequest", "deliverTo", element.getDeliverTo(), -1);
21185    }
21186  }
21187
21188  protected void composeSupplyRequestParameterComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestParameterComponent element, int index) {
21189    if (element == null) 
21190      return;
21191    Complex t;
21192    if (Utilities.noString(parentType))
21193      t = parent;
21194    else {
21195      t = parent.predicate("fhir:"+parentType+'.'+name);
21196    }
21197    composeBackboneElement(t, "parameter", name, element, index);
21198    if (element.hasCode()) {
21199      composeCodeableConcept(t, "SupplyRequestParameterComponent", "code", element.getCode(), -1);
21200    }
21201    if (element.hasValue()) {
21202      composeType(t, "SupplyRequestParameterComponent", "value", element.getValue(), -1);
21203    }
21204  }
21205
21206  protected void composeTask(Complex parent, String parentType, String name, Task element, int index) {
21207    if (element == null) 
21208      return;
21209    Complex t;
21210    if (Utilities.noString(parentType))
21211      t = parent;
21212    else {
21213      t = parent.predicate("fhir:"+parentType+'.'+name);
21214    }
21215    composeDomainResource(t, "Task", name, element, index);
21216    for (int i = 0; i < element.getIdentifier().size(); i++) {
21217      composeIdentifier(t, "Task", "identifier", element.getIdentifier().get(i), i);
21218    }
21219    if (element.hasInstantiatesCanonicalElement()) {
21220      composeCanonical(t, "Task", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1);
21221    }
21222    if (element.hasInstantiatesUriElement()) {
21223      composeUri(t, "Task", "instantiatesUri", element.getInstantiatesUriElement(), -1);
21224    }
21225    for (int i = 0; i < element.getBasedOn().size(); i++) {
21226      composeReference(t, "Task", "basedOn", element.getBasedOn().get(i), i);
21227    }
21228    if (element.hasGroupIdentifier()) {
21229      composeIdentifier(t, "Task", "groupIdentifier", element.getGroupIdentifier(), -1);
21230    }
21231    for (int i = 0; i < element.getPartOf().size(); i++) {
21232      composeReference(t, "Task", "partOf", element.getPartOf().get(i), i);
21233    }
21234    if (element.hasStatusElement()) {
21235      composeEnum(t, "Task", "status", element.getStatusElement(), -1);
21236    }
21237    if (element.hasStatusReason()) {
21238      composeCodeableConcept(t, "Task", "statusReason", element.getStatusReason(), -1);
21239    }
21240    if (element.hasBusinessStatus()) {
21241      composeCodeableConcept(t, "Task", "businessStatus", element.getBusinessStatus(), -1);
21242    }
21243    if (element.hasIntentElement()) {
21244      composeEnum(t, "Task", "intent", element.getIntentElement(), -1);
21245    }
21246    if (element.hasPriorityElement()) {
21247      composeEnum(t, "Task", "priority", element.getPriorityElement(), -1);
21248    }
21249    if (element.hasCode()) {
21250      composeCodeableConcept(t, "Task", "code", element.getCode(), -1);
21251    }
21252    if (element.hasDescriptionElement()) {
21253      composeString(t, "Task", "description", element.getDescriptionElement(), -1);
21254    }
21255    if (element.hasFocus()) {
21256      composeReference(t, "Task", "focus", element.getFocus(), -1);
21257    }
21258    if (element.hasFor()) {
21259      composeReference(t, "Task", "for", element.getFor(), -1);
21260    }
21261    if (element.hasEncounter()) {
21262      composeReference(t, "Task", "encounter", element.getEncounter(), -1);
21263    }
21264    if (element.hasExecutionPeriod()) {
21265      composePeriod(t, "Task", "executionPeriod", element.getExecutionPeriod(), -1);
21266    }
21267    if (element.hasAuthoredOnElement()) {
21268      composeDateTime(t, "Task", "authoredOn", element.getAuthoredOnElement(), -1);
21269    }
21270    if (element.hasLastModifiedElement()) {
21271      composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1);
21272    }
21273    if (element.hasRequester()) {
21274      composeReference(t, "Task", "requester", element.getRequester(), -1);
21275    }
21276    for (int i = 0; i < element.getPerformerType().size(); i++) {
21277      composeCodeableConcept(t, "Task", "performerType", element.getPerformerType().get(i), i);
21278    }
21279    if (element.hasOwner()) {
21280      composeReference(t, "Task", "owner", element.getOwner(), -1);
21281    }
21282    if (element.hasLocation()) {
21283      composeReference(t, "Task", "location", element.getLocation(), -1);
21284    }
21285    if (element.hasReasonCode()) {
21286      composeCodeableConcept(t, "Task", "reasonCode", element.getReasonCode(), -1);
21287    }
21288    if (element.hasReasonReference()) {
21289      composeReference(t, "Task", "reasonReference", element.getReasonReference(), -1);
21290    }
21291    for (int i = 0; i < element.getInsurance().size(); i++) {
21292      composeReference(t, "Task", "insurance", element.getInsurance().get(i), i);
21293    }
21294    for (int i = 0; i < element.getNote().size(); i++) {
21295      composeAnnotation(t, "Task", "note", element.getNote().get(i), i);
21296    }
21297    for (int i = 0; i < element.getRelevantHistory().size(); i++) {
21298      composeReference(t, "Task", "relevantHistory", element.getRelevantHistory().get(i), i);
21299    }
21300    if (element.hasRestriction()) {
21301      composeTaskRestrictionComponent(t, "Task", "restriction", element.getRestriction(), -1);
21302    }
21303    for (int i = 0; i < element.getInput().size(); i++) {
21304      composeTaskParameterComponent(t, "Task", "input", element.getInput().get(i), i);
21305    }
21306    for (int i = 0; i < element.getOutput().size(); i++) {
21307      composeTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i);
21308    }
21309  }
21310
21311  protected void composeTaskRestrictionComponent(Complex parent, String parentType, String name, Task.TaskRestrictionComponent element, int index) {
21312    if (element == null) 
21313      return;
21314    Complex t;
21315    if (Utilities.noString(parentType))
21316      t = parent;
21317    else {
21318      t = parent.predicate("fhir:"+parentType+'.'+name);
21319    }
21320    composeBackboneElement(t, "restriction", name, element, index);
21321    if (element.hasRepetitionsElement()) {
21322      composePositiveInt(t, "TaskRestrictionComponent", "repetitions", element.getRepetitionsElement(), -1);
21323    }
21324    if (element.hasPeriod()) {
21325      composePeriod(t, "TaskRestrictionComponent", "period", element.getPeriod(), -1);
21326    }
21327    for (int i = 0; i < element.getRecipient().size(); i++) {
21328      composeReference(t, "TaskRestrictionComponent", "recipient", element.getRecipient().get(i), i);
21329    }
21330  }
21331
21332  protected void composeTaskParameterComponent(Complex parent, String parentType, String name, Task.ParameterComponent element, int index) {
21333    if (element == null) 
21334      return;
21335    Complex t;
21336    if (Utilities.noString(parentType))
21337      t = parent;
21338    else {
21339      t = parent.predicate("fhir:"+parentType+'.'+name);
21340    }
21341    composeBackboneElement(t, "input", name, element, index);
21342    if (element.hasType()) {
21343      composeCodeableConcept(t, "ParameterComponent", "type", element.getType(), -1);
21344    }
21345    if (element.hasValue()) {
21346      composeType(t, "ParameterComponent", "value", element.getValue(), -1);
21347    }
21348  }
21349
21350  protected void composeTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent element, int index) {
21351    if (element == null) 
21352      return;
21353    Complex t;
21354    if (Utilities.noString(parentType))
21355      t = parent;
21356    else {
21357      t = parent.predicate("fhir:"+parentType+'.'+name);
21358    }
21359    composeBackboneElement(t, "output", name, element, index);
21360    if (element.hasType()) {
21361      composeCodeableConcept(t, "TaskOutputComponent", "type", element.getType(), -1);
21362    }
21363    if (element.hasValue()) {
21364      composeType(t, "TaskOutputComponent", "value", element.getValue(), -1);
21365    }
21366  }
21367
21368  protected void composeTerminologyCapabilities(Complex parent, String parentType, String name, TerminologyCapabilities element, int index) {
21369    if (element == null) 
21370      return;
21371    Complex t;
21372    if (Utilities.noString(parentType))
21373      t = parent;
21374    else {
21375      t = parent.predicate("fhir:"+parentType+'.'+name);
21376    }
21377    composeCanonicalResource(t, "TerminologyCapabilities", name, element, index);
21378    if (element.hasUrlElement()) {
21379      composeUri(t, "TerminologyCapabilities", "url", element.getUrlElement(), -1);
21380    }
21381    if (element.hasVersionElement()) {
21382      composeString(t, "TerminologyCapabilities", "version", element.getVersionElement(), -1);
21383    }
21384    if (element.hasNameElement()) {
21385      composeString(t, "TerminologyCapabilities", "name", element.getNameElement(), -1);
21386    }
21387    if (element.hasTitleElement()) {
21388      composeString(t, "TerminologyCapabilities", "title", element.getTitleElement(), -1);
21389    }
21390    if (element.hasStatusElement()) {
21391      composeEnum(t, "TerminologyCapabilities", "status", element.getStatusElement(), -1);
21392    }
21393    if (element.hasExperimentalElement()) {
21394      composeBoolean(t, "TerminologyCapabilities", "experimental", element.getExperimentalElement(), -1);
21395    }
21396    if (element.hasDateElement()) {
21397      composeDateTime(t, "TerminologyCapabilities", "date", element.getDateElement(), -1);
21398    }
21399    if (element.hasPublisherElement()) {
21400      composeString(t, "TerminologyCapabilities", "publisher", element.getPublisherElement(), -1);
21401    }
21402    for (int i = 0; i < element.getContact().size(); i++) {
21403      composeContactDetail(t, "TerminologyCapabilities", "contact", element.getContact().get(i), i);
21404    }
21405    if (element.hasDescriptionElement()) {
21406      composeMarkdown(t, "TerminologyCapabilities", "description", element.getDescriptionElement(), -1);
21407    }
21408    for (int i = 0; i < element.getUseContext().size(); i++) {
21409      composeUsageContext(t, "TerminologyCapabilities", "useContext", element.getUseContext().get(i), i);
21410    }
21411    for (int i = 0; i < element.getJurisdiction().size(); i++) {
21412      composeCodeableConcept(t, "TerminologyCapabilities", "jurisdiction", element.getJurisdiction().get(i), i);
21413    }
21414    if (element.hasPurposeElement()) {
21415      composeMarkdown(t, "TerminologyCapabilities", "purpose", element.getPurposeElement(), -1);
21416    }
21417    if (element.hasCopyrightElement()) {
21418      composeMarkdown(t, "TerminologyCapabilities", "copyright", element.getCopyrightElement(), -1);
21419    }
21420    if (element.hasKindElement()) {
21421      composeEnum(t, "TerminologyCapabilities", "kind", element.getKindElement(), -1);
21422    }
21423    if (element.hasSoftware()) {
21424      composeTerminologyCapabilitiesSoftwareComponent(t, "TerminologyCapabilities", "software", element.getSoftware(), -1);
21425    }
21426    if (element.hasImplementation()) {
21427      composeTerminologyCapabilitiesImplementationComponent(t, "TerminologyCapabilities", "implementation", element.getImplementation(), -1);
21428    }
21429    if (element.hasLockedDateElement()) {
21430      composeBoolean(t, "TerminologyCapabilities", "lockedDate", element.getLockedDateElement(), -1);
21431    }
21432    for (int i = 0; i < element.getCodeSystem().size(); i++) {
21433      composeTerminologyCapabilitiesCodeSystemComponent(t, "TerminologyCapabilities", "codeSystem", element.getCodeSystem().get(i), i);
21434    }
21435    if (element.hasExpansion()) {
21436      composeTerminologyCapabilitiesExpansionComponent(t, "TerminologyCapabilities", "expansion", element.getExpansion(), -1);
21437    }
21438    if (element.hasCodeSearchElement()) {
21439      composeEnum(t, "TerminologyCapabilities", "codeSearch", element.getCodeSearchElement(), -1);
21440    }
21441    if (element.hasValidateCode()) {
21442      composeTerminologyCapabilitiesValidateCodeComponent(t, "TerminologyCapabilities", "validateCode", element.getValidateCode(), -1);
21443    }
21444    if (element.hasTranslation()) {
21445      composeTerminologyCapabilitiesTranslationComponent(t, "TerminologyCapabilities", "translation", element.getTranslation(), -1);
21446    }
21447    if (element.hasClosure()) {
21448      composeTerminologyCapabilitiesClosureComponent(t, "TerminologyCapabilities", "closure", element.getClosure(), -1);
21449    }
21450  }
21451
21452  protected void composeTerminologyCapabilitiesSoftwareComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesSoftwareComponent element, int index) {
21453    if (element == null) 
21454      return;
21455    Complex t;
21456    if (Utilities.noString(parentType))
21457      t = parent;
21458    else {
21459      t = parent.predicate("fhir:"+parentType+'.'+name);
21460    }
21461    composeBackboneElement(t, "software", name, element, index);
21462    if (element.hasNameElement()) {
21463      composeString(t, "TerminologyCapabilitiesSoftwareComponent", "name", element.getNameElement(), -1);
21464    }
21465    if (element.hasVersionElement()) {
21466      composeString(t, "TerminologyCapabilitiesSoftwareComponent", "version", element.getVersionElement(), -1);
21467    }
21468  }
21469
21470  protected void composeTerminologyCapabilitiesImplementationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesImplementationComponent 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, "implementation", name, element, index);
21480    if (element.hasDescriptionElement()) {
21481      composeString(t, "TerminologyCapabilitiesImplementationComponent", "description", element.getDescriptionElement(), -1);
21482    }
21483    if (element.hasUrlElement()) {
21484      composeUrl(t, "TerminologyCapabilitiesImplementationComponent", "url", element.getUrlElement(), -1);
21485    }
21486  }
21487
21488  protected void composeTerminologyCapabilitiesCodeSystemComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemComponent 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, "codeSystem", name, element, index);
21498    if (element.hasUriElement()) {
21499      composeCanonical(t, "TerminologyCapabilitiesCodeSystemComponent", "uri", element.getUriElement(), -1);
21500    }
21501    for (int i = 0; i < element.getVersion().size(); i++) {
21502      composeTerminologyCapabilitiesCodeSystemVersionComponent(t, "TerminologyCapabilitiesCodeSystemComponent", "version", element.getVersion().get(i), i);
21503    }
21504    if (element.hasSubsumptionElement()) {
21505      composeBoolean(t, "TerminologyCapabilitiesCodeSystemComponent", "subsumption", element.getSubsumptionElement(), -1);
21506    }
21507  }
21508
21509  protected void composeTerminologyCapabilitiesCodeSystemVersionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionComponent element, int index) {
21510    if (element == null) 
21511      return;
21512    Complex t;
21513    if (Utilities.noString(parentType))
21514      t = parent;
21515    else {
21516      t = parent.predicate("fhir:"+parentType+'.'+name);
21517    }
21518    composeBackboneElement(t, "version", name, element, index);
21519    if (element.hasCodeElement()) {
21520      composeString(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "code", element.getCodeElement(), -1);
21521    }
21522    if (element.hasIsDefaultElement()) {
21523      composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "isDefault", element.getIsDefaultElement(), -1);
21524    }
21525    if (element.hasCompositionalElement()) {
21526      composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "compositional", element.getCompositionalElement(), -1);
21527    }
21528    for (int i = 0; i < element.getLanguage().size(); i++) {
21529      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "language", element.getLanguage().get(i), i);
21530    }
21531    for (int i = 0; i < element.getFilter().size(); i++) {
21532      composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "filter", element.getFilter().get(i), i);
21533    }
21534    for (int i = 0; i < element.getProperty().size(); i++) {
21535      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "property", element.getProperty().get(i), i);
21536    }
21537  }
21538
21539  protected void composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionFilterComponent element, int index) {
21540    if (element == null) 
21541      return;
21542    Complex t;
21543    if (Utilities.noString(parentType))
21544      t = parent;
21545    else {
21546      t = parent.predicate("fhir:"+parentType+'.'+name);
21547    }
21548    composeBackboneElement(t, "filter", name, element, index);
21549    if (element.hasCodeElement()) {
21550      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "code", element.getCodeElement(), -1);
21551    }
21552    for (int i = 0; i < element.getOp().size(); i++) {
21553      composeCode(t, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "op", element.getOp().get(i), i);
21554    }
21555  }
21556
21557  protected void composeTerminologyCapabilitiesExpansionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionComponent element, int index) {
21558    if (element == null) 
21559      return;
21560    Complex t;
21561    if (Utilities.noString(parentType))
21562      t = parent;
21563    else {
21564      t = parent.predicate("fhir:"+parentType+'.'+name);
21565    }
21566    composeBackboneElement(t, "expansion", name, element, index);
21567    if (element.hasHierarchicalElement()) {
21568      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "hierarchical", element.getHierarchicalElement(), -1);
21569    }
21570    if (element.hasPagingElement()) {
21571      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "paging", element.getPagingElement(), -1);
21572    }
21573    if (element.hasIncompleteElement()) {
21574      composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "incomplete", element.getIncompleteElement(), -1);
21575    }
21576    for (int i = 0; i < element.getParameter().size(); i++) {
21577      composeTerminologyCapabilitiesExpansionParameterComponent(t, "TerminologyCapabilitiesExpansionComponent", "parameter", element.getParameter().get(i), i);
21578    }
21579    if (element.hasTextFilterElement()) {
21580      composeMarkdown(t, "TerminologyCapabilitiesExpansionComponent", "textFilter", element.getTextFilterElement(), -1);
21581    }
21582  }
21583
21584  protected void composeTerminologyCapabilitiesExpansionParameterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionParameterComponent element, int index) {
21585    if (element == null) 
21586      return;
21587    Complex t;
21588    if (Utilities.noString(parentType))
21589      t = parent;
21590    else {
21591      t = parent.predicate("fhir:"+parentType+'.'+name);
21592    }
21593    composeBackboneElement(t, "parameter", name, element, index);
21594    if (element.hasNameElement()) {
21595      composeCode(t, "TerminologyCapabilitiesExpansionParameterComponent", "name", element.getNameElement(), -1);
21596    }
21597    if (element.hasDocumentationElement()) {
21598      composeString(t, "TerminologyCapabilitiesExpansionParameterComponent", "documentation", element.getDocumentationElement(), -1);
21599    }
21600  }
21601
21602  protected void composeTerminologyCapabilitiesValidateCodeComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesValidateCodeComponent 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, "validateCode", name, element, index);
21612    if (element.hasTranslationsElement()) {
21613      composeBoolean(t, "TerminologyCapabilitiesValidateCodeComponent", "translations", element.getTranslationsElement(), -1);
21614    }
21615  }
21616
21617  protected void composeTerminologyCapabilitiesTranslationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesTranslationComponent 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, "translation", name, element, index);
21627    if (element.hasNeedsMapElement()) {
21628      composeBoolean(t, "TerminologyCapabilitiesTranslationComponent", "needsMap", element.getNeedsMapElement(), -1);
21629    }
21630  }
21631
21632  protected void composeTerminologyCapabilitiesClosureComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesClosureComponent element, int index) {
21633    if (element == null) 
21634      return;
21635    Complex t;
21636    if (Utilities.noString(parentType))
21637      t = parent;
21638    else {
21639      t = parent.predicate("fhir:"+parentType+'.'+name);
21640    }
21641    composeBackboneElement(t, "closure", name, element, index);
21642    if (element.hasTranslationElement()) {
21643      composeBoolean(t, "TerminologyCapabilitiesClosureComponent", "translation", element.getTranslationElement(), -1);
21644    }
21645  }
21646
21647  protected void composeTestReport(Complex parent, String parentType, String name, TestReport element, int index) {
21648    if (element == null) 
21649      return;
21650    Complex t;
21651    if (Utilities.noString(parentType))
21652      t = parent;
21653    else {
21654      t = parent.predicate("fhir:"+parentType+'.'+name);
21655    }
21656    composeDomainResource(t, "TestReport", name, element, index);
21657    if (element.hasIdentifier()) {
21658      composeIdentifier(t, "TestReport", "identifier", element.getIdentifier(), -1);
21659    }
21660    if (element.hasNameElement()) {
21661      composeString(t, "TestReport", "name", element.getNameElement(), -1);
21662    }
21663    if (element.hasStatusElement()) {
21664      composeEnum(t, "TestReport", "status", element.getStatusElement(), -1);
21665    }
21666    if (element.hasTestScript()) {
21667      composeReference(t, "TestReport", "testScript", element.getTestScript(), -1);
21668    }
21669    if (element.hasResultElement()) {
21670      composeEnum(t, "TestReport", "result", element.getResultElement(), -1);
21671    }
21672    if (element.hasScoreElement()) {
21673      composeDecimal(t, "TestReport", "score", element.getScoreElement(), -1);
21674    }
21675    if (element.hasTesterElement()) {
21676      composeString(t, "TestReport", "tester", element.getTesterElement(), -1);
21677    }
21678    if (element.hasIssuedElement()) {
21679      composeDateTime(t, "TestReport", "issued", element.getIssuedElement(), -1);
21680    }
21681    for (int i = 0; i < element.getParticipant().size(); i++) {
21682      composeTestReportParticipantComponent(t, "TestReport", "participant", element.getParticipant().get(i), i);
21683    }
21684    if (element.hasSetup()) {
21685      composeTestReportSetupComponent(t, "TestReport", "setup", element.getSetup(), -1);
21686    }
21687    for (int i = 0; i < element.getTest().size(); i++) {
21688      composeTestReportTestComponent(t, "TestReport", "test", element.getTest().get(i), i);
21689    }
21690    if (element.hasTeardown()) {
21691      composeTestReportTeardownComponent(t, "TestReport", "teardown", element.getTeardown(), -1);
21692    }
21693  }
21694
21695  protected void composeTestReportParticipantComponent(Complex parent, String parentType, String name, TestReport.TestReportParticipantComponent element, int index) {
21696    if (element == null) 
21697      return;
21698    Complex t;
21699    if (Utilities.noString(parentType))
21700      t = parent;
21701    else {
21702      t = parent.predicate("fhir:"+parentType+'.'+name);
21703    }
21704    composeBackboneElement(t, "participant", name, element, index);
21705    if (element.hasTypeElement()) {
21706      composeEnum(t, "TestReportParticipantComponent", "type", element.getTypeElement(), -1);
21707    }
21708    if (element.hasUriElement()) {
21709      composeUri(t, "TestReportParticipantComponent", "uri", element.getUriElement(), -1);
21710    }
21711    if (element.hasDisplayElement()) {
21712      composeString(t, "TestReportParticipantComponent", "display", element.getDisplayElement(), -1);
21713    }
21714  }
21715
21716  protected void composeTestReportSetupComponent(Complex parent, String parentType, String name, TestReport.TestReportSetupComponent 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, "setup", name, element, index);
21726    for (int i = 0; i < element.getAction().size(); i++) {
21727      composeTestReportSetupActionComponent(t, "TestReportSetupComponent", "action", element.getAction().get(i), i);
21728    }
21729  }
21730
21731  protected void composeTestReportSetupActionComponent(Complex parent, String parentType, String name, TestReport.SetupActionComponent 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, "SetupActionComponent", "operation", element.getOperation(), -1);
21743    }
21744    if (element.hasAssert()) {
21745      composeTestReportSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1);
21746    }
21747  }
21748
21749  protected void composeTestReportSetupActionOperationComponent(Complex parent, String parentType, String name, TestReport.SetupActionOperationComponent element, int index) {
21750    if (element == null) 
21751      return;
21752    Complex t;
21753    if (Utilities.noString(parentType))
21754      t = parent;
21755    else {
21756      t = parent.predicate("fhir:"+parentType+'.'+name);
21757    }
21758    composeBackboneElement(t, "operation", name, element, index);
21759    if (element.hasResultElement()) {
21760      composeEnum(t, "SetupActionOperationComponent", "result", element.getResultElement(), -1);
21761    }
21762    if (element.hasMessageElement()) {
21763      composeMarkdown(t, "SetupActionOperationComponent", "message", element.getMessageElement(), -1);
21764    }
21765    if (element.hasDetailElement()) {
21766      composeUri(t, "SetupActionOperationComponent", "detail", element.getDetailElement(), -1);
21767    }
21768  }
21769
21770  protected void composeTestReportSetupActionAssertComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertComponent element, int index) {
21771    if (element == null) 
21772      return;
21773    Complex t;
21774    if (Utilities.noString(parentType))
21775      t = parent;
21776    else {
21777      t = parent.predicate("fhir:"+parentType+'.'+name);
21778    }
21779    composeBackboneElement(t, "assert", name, element, index);
21780    if (element.hasResultElement()) {
21781      composeEnum(t, "SetupActionAssertComponent", "result", element.getResultElement(), -1);
21782    }
21783    if (element.hasMessageElement()) {
21784      composeMarkdown(t, "SetupActionAssertComponent", "message", element.getMessageElement(), -1);
21785    }
21786    if (element.hasDetailElement()) {
21787      composeString(t, "SetupActionAssertComponent", "detail", element.getDetailElement(), -1);
21788    }
21789  }
21790
21791  protected void composeTestReportTestComponent(Complex parent, String parentType, String name, TestReport.TestReportTestComponent element, int index) {
21792    if (element == null) 
21793      return;
21794    Complex t;
21795    if (Utilities.noString(parentType))
21796      t = parent;
21797    else {
21798      t = parent.predicate("fhir:"+parentType+'.'+name);
21799    }
21800    composeBackboneElement(t, "test", name, element, index);
21801    if (element.hasNameElement()) {
21802      composeString(t, "TestReportTestComponent", "name", element.getNameElement(), -1);
21803    }
21804    if (element.hasDescriptionElement()) {
21805      composeString(t, "TestReportTestComponent", "description", element.getDescriptionElement(), -1);
21806    }
21807    for (int i = 0; i < element.getAction().size(); i++) {
21808      composeTestReportTestActionComponent(t, "TestReportTestComponent", "action", element.getAction().get(i), i);
21809    }
21810  }
21811
21812  protected void composeTestReportTestActionComponent(Complex parent, String parentType, String name, TestReport.TestActionComponent element, int index) {
21813    if (element == null) 
21814      return;
21815    Complex t;
21816    if (Utilities.noString(parentType))
21817      t = parent;
21818    else {
21819      t = parent.predicate("fhir:"+parentType+'.'+name);
21820    }
21821    composeBackboneElement(t, "action", name, element, index);
21822    if (element.hasOperation()) {
21823      composeTestReportSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1);
21824    }
21825    if (element.hasAssert()) {
21826      composeTestReportSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1);
21827    }
21828  }
21829
21830  protected void composeTestReportTeardownComponent(Complex parent, String parentType, String name, TestReport.TestReportTeardownComponent 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, "teardown", name, element, index);
21840    for (int i = 0; i < element.getAction().size(); i++) {
21841      composeTestReportTeardownActionComponent(t, "TestReportTeardownComponent", "action", element.getAction().get(i), i);
21842    }
21843  }
21844
21845  protected void composeTestReportTeardownActionComponent(Complex parent, String parentType, String name, TestReport.TeardownActionComponent element, int index) {
21846    if (element == null) 
21847      return;
21848    Complex t;
21849    if (Utilities.noString(parentType))
21850      t = parent;
21851    else {
21852      t = parent.predicate("fhir:"+parentType+'.'+name);
21853    }
21854    composeBackboneElement(t, "action", name, element, index);
21855    if (element.hasOperation()) {
21856      composeTestReportSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1);
21857    }
21858  }
21859
21860  protected void composeTestScript(Complex parent, String parentType, String name, TestScript element, int index) {
21861    if (element == null) 
21862      return;
21863    Complex t;
21864    if (Utilities.noString(parentType))
21865      t = parent;
21866    else {
21867      t = parent.predicate("fhir:"+parentType+'.'+name);
21868    }
21869    composeCanonicalResource(t, "TestScript", name, element, index);
21870    if (element.hasUrlElement()) {
21871      composeUri(t, "TestScript", "url", element.getUrlElement(), -1);
21872    }
21873    if (element.hasIdentifier()) {
21874      composeIdentifier(t, "TestScript", "identifier", element.getIdentifierFirstRep(), -1);
21875    }
21876    if (element.hasVersionElement()) {
21877      composeString(t, "TestScript", "version", element.getVersionElement(), -1);
21878    }
21879    if (element.hasNameElement()) {
21880      composeString(t, "TestScript", "name", element.getNameElement(), -1);
21881    }
21882    if (element.hasTitleElement()) {
21883      composeString(t, "TestScript", "title", element.getTitleElement(), -1);
21884    }
21885    if (element.hasStatusElement()) {
21886      composeEnum(t, "TestScript", "status", element.getStatusElement(), -1);
21887    }
21888    if (element.hasExperimentalElement()) {
21889      composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1);
21890    }
21891    if (element.hasDateElement()) {
21892      composeDateTime(t, "TestScript", "date", element.getDateElement(), -1);
21893    }
21894    if (element.hasPublisherElement()) {
21895      composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1);
21896    }
21897    for (int i = 0; i < element.getContact().size(); i++) {
21898      composeContactDetail(t, "TestScript", "contact", element.getContact().get(i), i);
21899    }
21900    if (element.hasDescriptionElement()) {
21901      composeMarkdown(t, "TestScript", "description", element.getDescriptionElement(), -1);
21902    }
21903    for (int i = 0; i < element.getUseContext().size(); i++) {
21904      composeUsageContext(t, "TestScript", "useContext", element.getUseContext().get(i), i);
21905    }
21906    for (int i = 0; i < element.getJurisdiction().size(); i++) {
21907      composeCodeableConcept(t, "TestScript", "jurisdiction", element.getJurisdiction().get(i), i);
21908    }
21909    if (element.hasPurposeElement()) {
21910      composeMarkdown(t, "TestScript", "purpose", element.getPurposeElement(), -1);
21911    }
21912    if (element.hasCopyrightElement()) {
21913      composeMarkdown(t, "TestScript", "copyright", element.getCopyrightElement(), -1);
21914    }
21915    for (int i = 0; i < element.getOrigin().size(); i++) {
21916      composeTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i);
21917    }
21918    for (int i = 0; i < element.getDestination().size(); i++) {
21919      composeTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i);
21920    }
21921    if (element.hasMetadata()) {
21922      composeTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1);
21923    }
21924    for (int i = 0; i < element.getFixture().size(); i++) {
21925      composeTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i);
21926    }
21927    for (int i = 0; i < element.getProfile().size(); i++) {
21928      composeReference(t, "TestScript", "profile", element.getProfile().get(i), i);
21929    }
21930    for (int i = 0; i < element.getVariable().size(); i++) {
21931      composeTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i);
21932    }
21933    if (element.hasSetup()) {
21934      composeTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1);
21935    }
21936    for (int i = 0; i < element.getTest().size(); i++) {
21937      composeTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i);
21938    }
21939    if (element.hasTeardown()) {
21940      composeTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1);
21941    }
21942  }
21943
21944  protected void composeTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent element, int index) {
21945    if (element == null) 
21946      return;
21947    Complex t;
21948    if (Utilities.noString(parentType))
21949      t = parent;
21950    else {
21951      t = parent.predicate("fhir:"+parentType+'.'+name);
21952    }
21953    composeBackboneElement(t, "origin", name, element, index);
21954    if (element.hasIndexElement()) {
21955      composeInteger(t, "TestScriptOriginComponent", "index", element.getIndexElement(), -1);
21956    }
21957    if (element.hasProfile()) {
21958      composeCoding(t, "TestScriptOriginComponent", "profile", element.getProfile(), -1);
21959    }
21960  }
21961
21962  protected void composeTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent element, int index) {
21963    if (element == null) 
21964      return;
21965    Complex t;
21966    if (Utilities.noString(parentType))
21967      t = parent;
21968    else {
21969      t = parent.predicate("fhir:"+parentType+'.'+name);
21970    }
21971    composeBackboneElement(t, "destination", name, element, index);
21972    if (element.hasIndexElement()) {
21973      composeInteger(t, "TestScriptDestinationComponent", "index", element.getIndexElement(), -1);
21974    }
21975    if (element.hasProfile()) {
21976      composeCoding(t, "TestScriptDestinationComponent", "profile", element.getProfile(), -1);
21977    }
21978  }
21979
21980  protected void composeTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent element, int index) {
21981    if (element == null) 
21982      return;
21983    Complex t;
21984    if (Utilities.noString(parentType))
21985      t = parent;
21986    else {
21987      t = parent.predicate("fhir:"+parentType+'.'+name);
21988    }
21989    composeBackboneElement(t, "metadata", name, element, index);
21990    for (int i = 0; i < element.getLink().size(); i++) {
21991      composeTestScriptMetadataLinkComponent(t, "TestScriptMetadataComponent", "link", element.getLink().get(i), i);
21992    }
21993    for (int i = 0; i < element.getCapability().size(); i++) {
21994      composeTestScriptMetadataCapabilityComponent(t, "TestScriptMetadataComponent", "capability", element.getCapability().get(i), i);
21995    }
21996  }
21997
21998  protected void composeTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent element, int index) {
21999    if (element == null) 
22000      return;
22001    Complex t;
22002    if (Utilities.noString(parentType))
22003      t = parent;
22004    else {
22005      t = parent.predicate("fhir:"+parentType+'.'+name);
22006    }
22007    composeBackboneElement(t, "link", name, element, index);
22008    if (element.hasUrlElement()) {
22009      composeUri(t, "TestScriptMetadataLinkComponent", "url", element.getUrlElement(), -1);
22010    }
22011    if (element.hasDescriptionElement()) {
22012      composeString(t, "TestScriptMetadataLinkComponent", "description", element.getDescriptionElement(), -1);
22013    }
22014  }
22015
22016  protected void composeTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent element, int index) {
22017    if (element == null) 
22018      return;
22019    Complex t;
22020    if (Utilities.noString(parentType))
22021      t = parent;
22022    else {
22023      t = parent.predicate("fhir:"+parentType+'.'+name);
22024    }
22025    composeBackboneElement(t, "capability", name, element, index);
22026    if (element.hasRequiredElement()) {
22027      composeBoolean(t, "TestScriptMetadataCapabilityComponent", "required", element.getRequiredElement(), -1);
22028    }
22029    if (element.hasValidatedElement()) {
22030      composeBoolean(t, "TestScriptMetadataCapabilityComponent", "validated", element.getValidatedElement(), -1);
22031    }
22032    if (element.hasDescriptionElement()) {
22033      composeString(t, "TestScriptMetadataCapabilityComponent", "description", element.getDescriptionElement(), -1);
22034    }
22035    for (int i = 0; i < element.getOrigin().size(); i++) {
22036      composeInteger(t, "TestScriptMetadataCapabilityComponent", "origin", element.getOrigin().get(i), i);
22037    }
22038    if (element.hasDestinationElement()) {
22039      composeInteger(t, "TestScriptMetadataCapabilityComponent", "destination", element.getDestinationElement(), -1);
22040    }
22041    for (int i = 0; i < element.getLink().size(); i++) {
22042      composeUri(t, "TestScriptMetadataCapabilityComponent", "link", element.getLink().get(i), i);
22043    }
22044    if (element.hasCapabilitiesElement()) {
22045      composeCanonical(t, "TestScriptMetadataCapabilityComponent", "capabilities", element.getCapabilitiesElement(), -1);
22046    }
22047  }
22048
22049  protected void composeTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent element, int index) {
22050    if (element == null) 
22051      return;
22052    Complex t;
22053    if (Utilities.noString(parentType))
22054      t = parent;
22055    else {
22056      t = parent.predicate("fhir:"+parentType+'.'+name);
22057    }
22058    composeBackboneElement(t, "fixture", name, element, index);
22059    if (element.hasAutocreateElement()) {
22060      composeBoolean(t, "TestScriptFixtureComponent", "autocreate", element.getAutocreateElement(), -1);
22061    }
22062    if (element.hasAutodeleteElement()) {
22063      composeBoolean(t, "TestScriptFixtureComponent", "autodelete", element.getAutodeleteElement(), -1);
22064    }
22065    if (element.hasResource()) {
22066      composeReference(t, "TestScriptFixtureComponent", "resource", element.getResource(), -1);
22067    }
22068  }
22069
22070  protected void composeTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent element, int index) {
22071    if (element == null) 
22072      return;
22073    Complex t;
22074    if (Utilities.noString(parentType))
22075      t = parent;
22076    else {
22077      t = parent.predicate("fhir:"+parentType+'.'+name);
22078    }
22079    composeBackboneElement(t, "variable", name, element, index);
22080    if (element.hasNameElement()) {
22081      composeString(t, "TestScriptVariableComponent", "name", element.getNameElement(), -1);
22082    }
22083    if (element.hasDefaultValueElement()) {
22084      composeString(t, "TestScriptVariableComponent", "defaultValue", element.getDefaultValueElement(), -1);
22085    }
22086    if (element.hasDescriptionElement()) {
22087      composeString(t, "TestScriptVariableComponent", "description", element.getDescriptionElement(), -1);
22088    }
22089    if (element.hasExpressionElement()) {
22090      composeString(t, "TestScriptVariableComponent", "expression", element.getExpressionElement(), -1);
22091    }
22092    if (element.hasHeaderFieldElement()) {
22093      composeString(t, "TestScriptVariableComponent", "headerField", element.getHeaderFieldElement(), -1);
22094    }
22095    if (element.hasHintElement()) {
22096      composeString(t, "TestScriptVariableComponent", "hint", element.getHintElement(), -1);
22097    }
22098    if (element.hasPathElement()) {
22099      composeString(t, "TestScriptVariableComponent", "path", element.getPathElement(), -1);
22100    }
22101    if (element.hasSourceIdElement()) {
22102      composeId(t, "TestScriptVariableComponent", "sourceId", element.getSourceIdElement(), -1);
22103    }
22104  }
22105
22106  protected void composeTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent 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, "setup", name, element, index);
22116    for (int i = 0; i < element.getAction().size(); i++) {
22117      composeTestScriptSetupActionComponent(t, "TestScriptSetupComponent", "action", element.getAction().get(i), i);
22118    }
22119  }
22120
22121  protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent element, int index) {
22122    if (element == null) 
22123      return;
22124    Complex t;
22125    if (Utilities.noString(parentType))
22126      t = parent;
22127    else {
22128      t = parent.predicate("fhir:"+parentType+'.'+name);
22129    }
22130    composeBackboneElement(t, "action", name, element, index);
22131    if (element.hasOperation()) {
22132      composeTestScriptSetupActionOperationComponent(t, "SetupActionComponent", "operation", element.getOperation(), -1);
22133    }
22134    if (element.hasAssert()) {
22135      composeTestScriptSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1);
22136    }
22137  }
22138
22139  protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent element, int index) {
22140    if (element == null) 
22141      return;
22142    Complex t;
22143    if (Utilities.noString(parentType))
22144      t = parent;
22145    else {
22146      t = parent.predicate("fhir:"+parentType+'.'+name);
22147    }
22148    composeBackboneElement(t, "operation", name, element, index);
22149    if (element.hasType()) {
22150      composeCoding(t, "SetupActionOperationComponent", "type", element.getType(), -1);
22151    }
22152    if (element.hasResourceElement()) {
22153      composeEnum(t, "SetupActionOperationComponent", "resource", element.getResourceElement(), -1);
22154    }
22155    if (element.hasLabelElement()) {
22156      composeString(t, "SetupActionOperationComponent", "label", element.getLabelElement(), -1);
22157    }
22158    if (element.hasDescriptionElement()) {
22159      composeString(t, "SetupActionOperationComponent", "description", element.getDescriptionElement(), -1);
22160    }
22161    if (element.hasAcceptElement()) {
22162      composeCode(t, "SetupActionOperationComponent", "accept", element.getAcceptElement(), -1);
22163    }
22164    if (element.hasContentTypeElement()) {
22165      composeCode(t, "SetupActionOperationComponent", "contentType", element.getContentTypeElement(), -1);
22166    }
22167    if (element.hasDestinationElement()) {
22168      composeInteger(t, "SetupActionOperationComponent", "destination", element.getDestinationElement(), -1);
22169    }
22170    if (element.hasEncodeRequestUrlElement()) {
22171      composeBoolean(t, "SetupActionOperationComponent", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1);
22172    }
22173    if (element.hasMethodElement()) {
22174      composeEnum(t, "SetupActionOperationComponent", "method", element.getMethodElement(), -1);
22175    }
22176    if (element.hasOriginElement()) {
22177      composeInteger(t, "SetupActionOperationComponent", "origin", element.getOriginElement(), -1);
22178    }
22179    if (element.hasParamsElement()) {
22180      composeString(t, "SetupActionOperationComponent", "params", element.getParamsElement(), -1);
22181    }
22182    for (int i = 0; i < element.getRequestHeader().size(); i++) {
22183      composeTestScriptSetupActionOperationRequestHeaderComponent(t, "SetupActionOperationComponent", "requestHeader", element.getRequestHeader().get(i), i);
22184    }
22185    if (element.hasRequestIdElement()) {
22186      composeId(t, "SetupActionOperationComponent", "requestId", element.getRequestIdElement(), -1);
22187    }
22188    if (element.hasResponseIdElement()) {
22189      composeId(t, "SetupActionOperationComponent", "responseId", element.getResponseIdElement(), -1);
22190    }
22191    if (element.hasSourceIdElement()) {
22192      composeId(t, "SetupActionOperationComponent", "sourceId", element.getSourceIdElement(), -1);
22193    }
22194    if (element.hasTargetIdElement()) {
22195      composeId(t, "SetupActionOperationComponent", "targetId", element.getTargetIdElement(), -1);
22196    }
22197    if (element.hasUrlElement()) {
22198      composeString(t, "SetupActionOperationComponent", "url", element.getUrlElement(), -1);
22199    }
22200  }
22201
22202  protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent element, int index) {
22203    if (element == null) 
22204      return;
22205    Complex t;
22206    if (Utilities.noString(parentType))
22207      t = parent;
22208    else {
22209      t = parent.predicate("fhir:"+parentType+'.'+name);
22210    }
22211    composeBackboneElement(t, "requestHeader", name, element, index);
22212    if (element.hasFieldElement()) {
22213      composeString(t, "SetupActionOperationRequestHeaderComponent", "field", element.getFieldElement(), -1);
22214    }
22215    if (element.hasValueElement()) {
22216      composeString(t, "SetupActionOperationRequestHeaderComponent", "value", element.getValueElement(), -1);
22217    }
22218  }
22219
22220  protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent element, int index) {
22221    if (element == null) 
22222      return;
22223    Complex t;
22224    if (Utilities.noString(parentType))
22225      t = parent;
22226    else {
22227      t = parent.predicate("fhir:"+parentType+'.'+name);
22228    }
22229    composeBackboneElement(t, "assert", name, element, index);
22230    if (element.hasLabelElement()) {
22231      composeString(t, "SetupActionAssertComponent", "label", element.getLabelElement(), -1);
22232    }
22233    if (element.hasDescriptionElement()) {
22234      composeString(t, "SetupActionAssertComponent", "description", element.getDescriptionElement(), -1);
22235    }
22236    if (element.hasDirectionElement()) {
22237      composeEnum(t, "SetupActionAssertComponent", "direction", element.getDirectionElement(), -1);
22238    }
22239    if (element.hasCompareToSourceIdElement()) {
22240      composeString(t, "SetupActionAssertComponent", "compareToSourceId", element.getCompareToSourceIdElement(), -1);
22241    }
22242    if (element.hasCompareToSourceExpressionElement()) {
22243      composeString(t, "SetupActionAssertComponent", "compareToSourceExpression", element.getCompareToSourceExpressionElement(), -1);
22244    }
22245    if (element.hasCompareToSourcePathElement()) {
22246      composeString(t, "SetupActionAssertComponent", "compareToSourcePath", element.getCompareToSourcePathElement(), -1);
22247    }
22248    if (element.hasContentTypeElement()) {
22249      composeCode(t, "SetupActionAssertComponent", "contentType", element.getContentTypeElement(), -1);
22250    }
22251    if (element.hasExpressionElement()) {
22252      composeString(t, "SetupActionAssertComponent", "expression", element.getExpressionElement(), -1);
22253    }
22254    if (element.hasHeaderFieldElement()) {
22255      composeString(t, "SetupActionAssertComponent", "headerField", element.getHeaderFieldElement(), -1);
22256    }
22257    if (element.hasMinimumIdElement()) {
22258      composeString(t, "SetupActionAssertComponent", "minimumId", element.getMinimumIdElement(), -1);
22259    }
22260    if (element.hasNavigationLinksElement()) {
22261      composeBoolean(t, "SetupActionAssertComponent", "navigationLinks", element.getNavigationLinksElement(), -1);
22262    }
22263    if (element.hasOperatorElement()) {
22264      composeEnum(t, "SetupActionAssertComponent", "operator", element.getOperatorElement(), -1);
22265    }
22266    if (element.hasPathElement()) {
22267      composeString(t, "SetupActionAssertComponent", "path", element.getPathElement(), -1);
22268    }
22269    if (element.hasRequestMethodElement()) {
22270      composeEnum(t, "SetupActionAssertComponent", "requestMethod", element.getRequestMethodElement(), -1);
22271    }
22272    if (element.hasRequestURLElement()) {
22273      composeString(t, "SetupActionAssertComponent", "requestURL", element.getRequestURLElement(), -1);
22274    }
22275    if (element.hasResourceElement()) {
22276      composeEnum(t, "SetupActionAssertComponent", "resource", element.getResourceElement(), -1);
22277    }
22278    if (element.hasResponseElement()) {
22279      composeEnum(t, "SetupActionAssertComponent", "response", element.getResponseElement(), -1);
22280    }
22281    if (element.hasResponseCodeElement()) {
22282      composeString(t, "SetupActionAssertComponent", "responseCode", element.getResponseCodeElement(), -1);
22283    }
22284    if (element.hasSourceIdElement()) {
22285      composeId(t, "SetupActionAssertComponent", "sourceId", element.getSourceIdElement(), -1);
22286    }
22287    if (element.hasValidateProfileIdElement()) {
22288      composeId(t, "SetupActionAssertComponent", "validateProfileId", element.getValidateProfileIdElement(), -1);
22289    }
22290    if (element.hasValueElement()) {
22291      composeString(t, "SetupActionAssertComponent", "value", element.getValueElement(), -1);
22292    }
22293    if (element.hasWarningOnlyElement()) {
22294      composeBoolean(t, "SetupActionAssertComponent", "warningOnly", element.getWarningOnlyElement(), -1);
22295    }
22296  }
22297
22298  protected void composeTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent element, int index) {
22299    if (element == null) 
22300      return;
22301    Complex t;
22302    if (Utilities.noString(parentType))
22303      t = parent;
22304    else {
22305      t = parent.predicate("fhir:"+parentType+'.'+name);
22306    }
22307    composeBackboneElement(t, "test", name, element, index);
22308    if (element.hasNameElement()) {
22309      composeString(t, "TestScriptTestComponent", "name", element.getNameElement(), -1);
22310    }
22311    if (element.hasDescriptionElement()) {
22312      composeString(t, "TestScriptTestComponent", "description", element.getDescriptionElement(), -1);
22313    }
22314    for (int i = 0; i < element.getAction().size(); i++) {
22315      composeTestScriptTestActionComponent(t, "TestScriptTestComponent", "action", element.getAction().get(i), i);
22316    }
22317  }
22318
22319  protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent 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, "action", name, element, index);
22329    if (element.hasOperation()) {
22330      composeTestScriptSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1);
22331    }
22332    if (element.hasAssert()) {
22333      composeTestScriptSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1);
22334    }
22335  }
22336
22337  protected void composeTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent element, int index) {
22338    if (element == null) 
22339      return;
22340    Complex t;
22341    if (Utilities.noString(parentType))
22342      t = parent;
22343    else {
22344      t = parent.predicate("fhir:"+parentType+'.'+name);
22345    }
22346    composeBackboneElement(t, "teardown", name, element, index);
22347    for (int i = 0; i < element.getAction().size(); i++) {
22348      composeTestScriptTeardownActionComponent(t, "TestScriptTeardownComponent", "action", element.getAction().get(i), i);
22349    }
22350  }
22351
22352  protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent element, int index) {
22353    if (element == null) 
22354      return;
22355    Complex t;
22356    if (Utilities.noString(parentType))
22357      t = parent;
22358    else {
22359      t = parent.predicate("fhir:"+parentType+'.'+name);
22360    }
22361    composeBackboneElement(t, "action", name, element, index);
22362    if (element.hasOperation()) {
22363      composeTestScriptSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1);
22364    }
22365  }
22366
22367  protected void composeTopic(Complex parent, String parentType, String name, Topic element, int index) {
22368    if (element == null) 
22369      return;
22370    Complex t;
22371    if (Utilities.noString(parentType))
22372      t = parent;
22373    else {
22374      t = parent.predicate("fhir:"+parentType+'.'+name);
22375    }
22376    composeDomainResource(t, "Topic", name, element, index);
22377    if (element.hasUrlElement()) {
22378      composeUri(t, "Topic", "url", element.getUrlElement(), -1);
22379    }
22380    for (int i = 0; i < element.getIdentifier().size(); i++) {
22381      composeIdentifier(t, "Topic", "identifier", element.getIdentifier().get(i), i);
22382    }
22383    if (element.hasVersionElement()) {
22384      composeString(t, "Topic", "version", element.getVersionElement(), -1);
22385    }
22386    if (element.hasTitleElement()) {
22387      composeString(t, "Topic", "title", element.getTitleElement(), -1);
22388    }
22389    for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) {
22390      composeCanonical(t, "Topic", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i);
22391    }
22392    for (int i = 0; i < element.getDerivedFromUri().size(); i++) {
22393      composeUri(t, "Topic", "derivedFromUri", element.getDerivedFromUri().get(i), i);
22394    }
22395    if (element.hasStatusElement()) {
22396      composeEnum(t, "Topic", "status", element.getStatusElement(), -1);
22397    }
22398    if (element.hasExperimentalElement()) {
22399      composeBoolean(t, "Topic", "experimental", element.getExperimentalElement(), -1);
22400    }
22401    if (element.hasDateElement()) {
22402      composeDateTime(t, "Topic", "date", element.getDateElement(), -1);
22403    }
22404    if (element.hasPublisher()) {
22405      composeReference(t, "Topic", "publisher", element.getPublisher(), -1);
22406    }
22407    for (int i = 0; i < element.getContact().size(); i++) {
22408      composeContactDetail(t, "Topic", "contact", element.getContact().get(i), i);
22409    }
22410    if (element.hasDescriptionElement()) {
22411      composeMarkdown(t, "Topic", "description", element.getDescriptionElement(), -1);
22412    }
22413    for (int i = 0; i < element.getUseContext().size(); i++) {
22414      composeUsageContext(t, "Topic", "useContext", element.getUseContext().get(i), i);
22415    }
22416    for (int i = 0; i < element.getJurisdiction().size(); i++) {
22417      composeCodeableConcept(t, "Topic", "jurisdiction", element.getJurisdiction().get(i), i);
22418    }
22419    if (element.hasPurposeElement()) {
22420      composeMarkdown(t, "Topic", "purpose", element.getPurposeElement(), -1);
22421    }
22422    if (element.hasCopyrightElement()) {
22423      composeMarkdown(t, "Topic", "copyright", element.getCopyrightElement(), -1);
22424    }
22425    if (element.hasApprovalDateElement()) {
22426      composeDate(t, "Topic", "approvalDate", element.getApprovalDateElement(), -1);
22427    }
22428    if (element.hasLastReviewDateElement()) {
22429      composeDate(t, "Topic", "lastReviewDate", element.getLastReviewDateElement(), -1);
22430    }
22431    if (element.hasEffectivePeriod()) {
22432      composePeriod(t, "Topic", "effectivePeriod", element.getEffectivePeriod(), -1);
22433    }
22434    if (element.hasResourceTrigger()) {
22435      composeTopicResourceTriggerComponent(t, "Topic", "resourceTrigger", element.getResourceTrigger(), -1);
22436    }
22437    for (int i = 0; i < element.getCanFilterBy().size(); i++) {
22438      composeTopicCanFilterByComponent(t, "Topic", "canFilterBy", element.getCanFilterBy().get(i), i);
22439    }
22440  }
22441
22442  protected void composeTopicResourceTriggerComponent(Complex parent, String parentType, String name, Topic.TopicResourceTriggerComponent element, int index) {
22443    if (element == null) 
22444      return;
22445    Complex t;
22446    if (Utilities.noString(parentType))
22447      t = parent;
22448    else {
22449      t = parent.predicate("fhir:"+parentType+'.'+name);
22450    }
22451    composeBackboneElement(t, "resourceTrigger", name, element, index);
22452    if (element.hasDescriptionElement()) {
22453      composeString(t, "TopicResourceTriggerComponent", "description", element.getDescriptionElement(), -1);
22454    }
22455    for (int i = 0; i < element.getResourceType().size(); i++) {
22456      composeCode(t, "TopicResourceTriggerComponent", "resourceType", element.getResourceType().get(i), i);
22457    }
22458    for (int i = 0; i < element.getMethodCriteria().size(); i++) {
22459      composeEnum(t, "TopicResourceTriggerComponent", "methodCriteria", element.getMethodCriteria().get(i), i);
22460    }
22461    if (element.hasQueryCriteria()) {
22462      composeTopicResourceTriggerQueryCriteriaComponent(t, "TopicResourceTriggerComponent", "queryCriteria", element.getQueryCriteria(), -1);
22463    }
22464    if (element.hasFhirPathCriteriaElement()) {
22465      composeString(t, "TopicResourceTriggerComponent", "fhirPathCriteria", element.getFhirPathCriteriaElement(), -1);
22466    }
22467  }
22468
22469  protected void composeTopicResourceTriggerQueryCriteriaComponent(Complex parent, String parentType, String name, Topic.TopicResourceTriggerQueryCriteriaComponent element, int index) {
22470    if (element == null) 
22471      return;
22472    Complex t;
22473    if (Utilities.noString(parentType))
22474      t = parent;
22475    else {
22476      t = parent.predicate("fhir:"+parentType+'.'+name);
22477    }
22478    composeBackboneElement(t, "queryCriteria", name, element, index);
22479    if (element.hasPreviousElement()) {
22480      composeString(t, "TopicResourceTriggerQueryCriteriaComponent", "previous", element.getPreviousElement(), -1);
22481    }
22482    if (element.hasCurrentElement()) {
22483      composeString(t, "TopicResourceTriggerQueryCriteriaComponent", "current", element.getCurrentElement(), -1);
22484    }
22485    if (element.hasRequireBothElement()) {
22486      composeBoolean(t, "TopicResourceTriggerQueryCriteriaComponent", "requireBoth", element.getRequireBothElement(), -1);
22487    }
22488  }
22489
22490  protected void composeTopicCanFilterByComponent(Complex parent, String parentType, String name, Topic.TopicCanFilterByComponent element, int index) {
22491    if (element == null) 
22492      return;
22493    Complex t;
22494    if (Utilities.noString(parentType))
22495      t = parent;
22496    else {
22497      t = parent.predicate("fhir:"+parentType+'.'+name);
22498    }
22499    composeBackboneElement(t, "canFilterBy", name, element, index);
22500    if (element.hasNameElement()) {
22501      composeString(t, "TopicCanFilterByComponent", "name", element.getNameElement(), -1);
22502    }
22503    for (int i = 0; i < element.getMatchType().size(); i++) {
22504      composeEnum(t, "TopicCanFilterByComponent", "matchType", element.getMatchType().get(i), i);
22505    }
22506    if (element.hasDocumentationElement()) {
22507      composeMarkdown(t, "TopicCanFilterByComponent", "documentation", element.getDocumentationElement(), -1);
22508    }
22509  }
22510
22511  protected void composeValueSet(Complex parent, String parentType, String name, ValueSet element, int index) {
22512    if (element == null) 
22513      return;
22514    Complex t;
22515    if (Utilities.noString(parentType))
22516      t = parent;
22517    else {
22518      t = parent.predicate("fhir:"+parentType+'.'+name);
22519    }
22520    composeCanonicalResource(t, "ValueSet", name, element, index);
22521    if (element.hasUrlElement()) {
22522      composeUri(t, "ValueSet", "url", element.getUrlElement(), -1);
22523    }
22524    for (int i = 0; i < element.getIdentifier().size(); i++) {
22525      composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier().get(i), i);
22526    }
22527    if (element.hasVersionElement()) {
22528      composeString(t, "ValueSet", "version", element.getVersionElement(), -1);
22529    }
22530    if (element.hasNameElement()) {
22531      composeString(t, "ValueSet", "name", element.getNameElement(), -1);
22532    }
22533    if (element.hasTitleElement()) {
22534      composeString(t, "ValueSet", "title", element.getTitleElement(), -1);
22535    }
22536    if (element.hasStatusElement()) {
22537      composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1);
22538    }
22539    if (element.hasExperimentalElement()) {
22540      composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1);
22541    }
22542    if (element.hasDateElement()) {
22543      composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1);
22544    }
22545    if (element.hasPublisherElement()) {
22546      composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1);
22547    }
22548    for (int i = 0; i < element.getContact().size(); i++) {
22549      composeContactDetail(t, "ValueSet", "contact", element.getContact().get(i), i);
22550    }
22551    if (element.hasDescriptionElement()) {
22552      composeMarkdown(t, "ValueSet", "description", element.getDescriptionElement(), -1);
22553    }
22554    for (int i = 0; i < element.getUseContext().size(); i++) {
22555      composeUsageContext(t, "ValueSet", "useContext", element.getUseContext().get(i), i);
22556    }
22557    for (int i = 0; i < element.getJurisdiction().size(); i++) {
22558      composeCodeableConcept(t, "ValueSet", "jurisdiction", element.getJurisdiction().get(i), i);
22559    }
22560    if (element.hasImmutableElement()) {
22561      composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1);
22562    }
22563    if (element.hasPurposeElement()) {
22564      composeMarkdown(t, "ValueSet", "purpose", element.getPurposeElement(), -1);
22565    }
22566    if (element.hasCopyrightElement()) {
22567      composeMarkdown(t, "ValueSet", "copyright", element.getCopyrightElement(), -1);
22568    }
22569    if (element.hasCompose()) {
22570      composeValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1);
22571    }
22572    if (element.hasExpansion()) {
22573      composeValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1);
22574    }
22575  }
22576
22577  protected void composeValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent element, int index) {
22578    if (element == null) 
22579      return;
22580    Complex t;
22581    if (Utilities.noString(parentType))
22582      t = parent;
22583    else {
22584      t = parent.predicate("fhir:"+parentType+'.'+name);
22585    }
22586    composeBackboneElement(t, "compose", name, element, index);
22587    if (element.hasLockedDateElement()) {
22588      composeDate(t, "ValueSetComposeComponent", "lockedDate", element.getLockedDateElement(), -1);
22589    }
22590    if (element.hasInactiveElement()) {
22591      composeBoolean(t, "ValueSetComposeComponent", "inactive", element.getInactiveElement(), -1);
22592    }
22593    for (int i = 0; i < element.getInclude().size(); i++) {
22594      composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "include", element.getInclude().get(i), i);
22595    }
22596    for (int i = 0; i < element.getExclude().size(); i++) {
22597      composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "exclude", element.getExclude().get(i), i);
22598    }
22599    for (int i = 0; i < element.getProperty().size(); i++) {
22600      composeString(t, "ValueSetComposeComponent", "property", element.getProperty().get(i), i);
22601    }
22602  }
22603
22604  protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent 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, "include", name, element, index);
22614    if (element.hasSystemElement()) {
22615      composeUri(t, "ConceptSetComponent", "system", element.getSystemElement(), -1);
22616    }
22617    if (element.hasVersionElement()) {
22618      composeString(t, "ConceptSetComponent", "version", element.getVersionElement(), -1);
22619    }
22620    for (int i = 0; i < element.getConcept().size(); i++) {
22621      composeValueSetConceptReferenceComponent(t, "ConceptSetComponent", "concept", element.getConcept().get(i), i);
22622    }
22623    for (int i = 0; i < element.getFilter().size(); i++) {
22624      composeValueSetConceptSetFilterComponent(t, "ConceptSetComponent", "filter", element.getFilter().get(i), i);
22625    }
22626    for (int i = 0; i < element.getValueSet().size(); i++) {
22627      composeCanonical(t, "ConceptSetComponent", "valueSet", element.getValueSet().get(i), i);
22628    }
22629  }
22630
22631  protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent element, int index) {
22632    if (element == null) 
22633      return;
22634    Complex t;
22635    if (Utilities.noString(parentType))
22636      t = parent;
22637    else {
22638      t = parent.predicate("fhir:"+parentType+'.'+name);
22639    }
22640    composeBackboneElement(t, "concept", name, element, index);
22641    if (element.hasCodeElement()) {
22642      composeCode(t, "ConceptReferenceComponent", "code", element.getCodeElement(), -1);
22643    }
22644    if (element.hasDisplayElement()) {
22645      composeString(t, "ConceptReferenceComponent", "display", element.getDisplayElement(), -1);
22646    }
22647    for (int i = 0; i < element.getDesignation().size(); i++) {
22648      composeValueSetConceptReferenceDesignationComponent(t, "ConceptReferenceComponent", "designation", element.getDesignation().get(i), i);
22649    }
22650  }
22651
22652  protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent element, int index) {
22653    if (element == null) 
22654      return;
22655    Complex t;
22656    if (Utilities.noString(parentType))
22657      t = parent;
22658    else {
22659      t = parent.predicate("fhir:"+parentType+'.'+name);
22660    }
22661    composeBackboneElement(t, "designation", name, element, index);
22662    if (element.hasLanguageElement()) {
22663      composeCode(t, "ConceptReferenceDesignationComponent", "language", element.getLanguageElement(), -1);
22664    }
22665    if (element.hasUse()) {
22666      composeCoding(t, "ConceptReferenceDesignationComponent", "use", element.getUse(), -1);
22667    }
22668    if (element.hasValueElement()) {
22669      composeString(t, "ConceptReferenceDesignationComponent", "value", element.getValueElement(), -1);
22670    }
22671  }
22672
22673  protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent element, int index) {
22674    if (element == null) 
22675      return;
22676    Complex t;
22677    if (Utilities.noString(parentType))
22678      t = parent;
22679    else {
22680      t = parent.predicate("fhir:"+parentType+'.'+name);
22681    }
22682    composeBackboneElement(t, "filter", name, element, index);
22683    if (element.hasPropertyElement()) {
22684      composeCode(t, "ConceptSetFilterComponent", "property", element.getPropertyElement(), -1);
22685    }
22686    if (element.hasOpElement()) {
22687      composeEnum(t, "ConceptSetFilterComponent", "op", element.getOpElement(), -1);
22688    }
22689    if (element.hasValueElement()) {
22690      composeString(t, "ConceptSetFilterComponent", "value", element.getValueElement(), -1);
22691    }
22692  }
22693
22694  protected void composeValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent element, int index) {
22695    if (element == null) 
22696      return;
22697    Complex t;
22698    if (Utilities.noString(parentType))
22699      t = parent;
22700    else {
22701      t = parent.predicate("fhir:"+parentType+'.'+name);
22702    }
22703    composeBackboneElement(t, "expansion", name, element, index);
22704    if (element.hasIdentifierElement()) {
22705      composeUri(t, "ValueSetExpansionComponent", "identifier", element.getIdentifierElement(), -1);
22706    }
22707    if (element.hasTimestampElement()) {
22708      composeDateTime(t, "ValueSetExpansionComponent", "timestamp", element.getTimestampElement(), -1);
22709    }
22710    if (element.hasTotalElement()) {
22711      composeInteger(t, "ValueSetExpansionComponent", "total", element.getTotalElement(), -1);
22712    }
22713    if (element.hasOffsetElement()) {
22714      composeInteger(t, "ValueSetExpansionComponent", "offset", element.getOffsetElement(), -1);
22715    }
22716    for (int i = 0; i < element.getParameter().size(); i++) {
22717      composeValueSetExpansionParameterComponent(t, "ValueSetExpansionComponent", "parameter", element.getParameter().get(i), i);
22718    }
22719    for (int i = 0; i < element.getProperty().size(); i++) {
22720      composeValueSetExpansionPropertyComponent(t, "ValueSetExpansionComponent", "property", element.getProperty().get(i), i);
22721    }
22722    for (int i = 0; i < element.getContains().size(); i++) {
22723      composeValueSetExpansionContainsComponent(t, "ValueSetExpansionComponent", "contains", element.getContains().get(i), i);
22724    }
22725  }
22726
22727  protected void composeValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent element, int index) {
22728    if (element == null) 
22729      return;
22730    Complex t;
22731    if (Utilities.noString(parentType))
22732      t = parent;
22733    else {
22734      t = parent.predicate("fhir:"+parentType+'.'+name);
22735    }
22736    composeBackboneElement(t, "parameter", name, element, index);
22737    if (element.hasNameElement()) {
22738      composeString(t, "ValueSetExpansionParameterComponent", "name", element.getNameElement(), -1);
22739    }
22740    if (element.hasValue()) {
22741      composeType(t, "ValueSetExpansionParameterComponent", "value", element.getValue(), -1);
22742    }
22743  }
22744
22745  protected void composeValueSetExpansionPropertyComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionPropertyComponent element, int index) {
22746    if (element == null) 
22747      return;
22748    Complex t;
22749    if (Utilities.noString(parentType))
22750      t = parent;
22751    else {
22752      t = parent.predicate("fhir:"+parentType+'.'+name);
22753    }
22754    composeBackboneElement(t, "property", name, element, index);
22755    if (element.hasCodeElement()) {
22756      composeCode(t, "ValueSetExpansionPropertyComponent", "code", element.getCodeElement(), -1);
22757    }
22758    if (element.hasUriElement()) {
22759      composeUri(t, "ValueSetExpansionPropertyComponent", "uri", element.getUriElement(), -1);
22760    }
22761  }
22762
22763  protected void composeValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent element, int index) {
22764    if (element == null) 
22765      return;
22766    Complex t;
22767    if (Utilities.noString(parentType))
22768      t = parent;
22769    else {
22770      t = parent.predicate("fhir:"+parentType+'.'+name);
22771    }
22772    composeBackboneElement(t, "contains", name, element, index);
22773    if (element.hasSystemElement()) {
22774      composeUri(t, "ValueSetExpansionContainsComponent", "system", element.getSystemElement(), -1);
22775    }
22776    if (element.hasAbstractElement()) {
22777      composeBoolean(t, "ValueSetExpansionContainsComponent", "abstract", element.getAbstractElement(), -1);
22778    }
22779    if (element.hasInactiveElement()) {
22780      composeBoolean(t, "ValueSetExpansionContainsComponent", "inactive", element.getInactiveElement(), -1);
22781    }
22782    if (element.hasVersionElement()) {
22783      composeString(t, "ValueSetExpansionContainsComponent", "version", element.getVersionElement(), -1);
22784    }
22785    if (element.hasCodeElement()) {
22786      composeCode(t, "ValueSetExpansionContainsComponent", "code", element.getCodeElement(), -1);
22787    }
22788    if (element.hasDisplayElement()) {
22789      composeString(t, "ValueSetExpansionContainsComponent", "display", element.getDisplayElement(), -1);
22790    }
22791    for (int i = 0; i < element.getDesignation().size(); i++) {
22792      composeValueSetConceptReferenceDesignationComponent(t, "ValueSetExpansionContainsComponent", "designation", element.getDesignation().get(i), i);
22793    }
22794    for (int i = 0; i < element.getProperty().size(); i++) {
22795      composeValueSetConceptPropertyComponent(t, "ValueSetExpansionContainsComponent", "property", element.getProperty().get(i), i);
22796    }
22797    for (int i = 0; i < element.getContains().size(); i++) {
22798      composeValueSetExpansionContainsComponent(t, "ValueSetExpansionContainsComponent", "contains", element.getContains().get(i), i);
22799    }
22800  }
22801
22802  protected void composeValueSetConceptPropertyComponent(Complex parent, String parentType, String name, ValueSet.ConceptPropertyComponent element, int index) {
22803    if (element == null) 
22804      return;
22805    Complex t;
22806    if (Utilities.noString(parentType))
22807      t = parent;
22808    else {
22809      t = parent.predicate("fhir:"+parentType+'.'+name);
22810    }
22811    composeBackboneElement(t, "property", name, element, index);
22812    if (element.hasCodeElement()) {
22813      composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1);
22814    }
22815    if (element.hasValue()) {
22816      composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1);
22817    }
22818  }
22819
22820  protected void composeVerificationResult(Complex parent, String parentType, String name, VerificationResult element, int index) {
22821    if (element == null) 
22822      return;
22823    Complex t;
22824    if (Utilities.noString(parentType))
22825      t = parent;
22826    else {
22827      t = parent.predicate("fhir:"+parentType+'.'+name);
22828    }
22829    composeDomainResource(t, "VerificationResult", name, element, index);
22830    for (int i = 0; i < element.getTarget().size(); i++) {
22831      composeReference(t, "VerificationResult", "target", element.getTarget().get(i), i);
22832    }
22833    for (int i = 0; i < element.getTargetLocation().size(); i++) {
22834      composeString(t, "VerificationResult", "targetLocation", element.getTargetLocation().get(i), i);
22835    }
22836    if (element.hasNeed()) {
22837      composeCodeableConcept(t, "VerificationResult", "need", element.getNeed(), -1);
22838    }
22839    if (element.hasStatusElement()) {
22840      composeEnum(t, "VerificationResult", "status", element.getStatusElement(), -1);
22841    }
22842    if (element.hasStatusDateElement()) {
22843      composeDateTime(t, "VerificationResult", "statusDate", element.getStatusDateElement(), -1);
22844    }
22845    if (element.hasValidationType()) {
22846      composeCodeableConcept(t, "VerificationResult", "validationType", element.getValidationType(), -1);
22847    }
22848    for (int i = 0; i < element.getValidationProcess().size(); i++) {
22849      composeCodeableConcept(t, "VerificationResult", "validationProcess", element.getValidationProcess().get(i), i);
22850    }
22851    if (element.hasFrequency()) {
22852      composeTiming(t, "VerificationResult", "frequency", element.getFrequency(), -1);
22853    }
22854    if (element.hasLastPerformedElement()) {
22855      composeDateTime(t, "VerificationResult", "lastPerformed", element.getLastPerformedElement(), -1);
22856    }
22857    if (element.hasNextScheduledElement()) {
22858      composeDate(t, "VerificationResult", "nextScheduled", element.getNextScheduledElement(), -1);
22859    }
22860    if (element.hasFailureAction()) {
22861      composeCodeableConcept(t, "VerificationResult", "failureAction", element.getFailureAction(), -1);
22862    }
22863    for (int i = 0; i < element.getPrimarySource().size(); i++) {
22864      composeVerificationResultPrimarySourceComponent(t, "VerificationResult", "primarySource", element.getPrimarySource().get(i), i);
22865    }
22866    if (element.hasAttestation()) {
22867      composeVerificationResultAttestationComponent(t, "VerificationResult", "attestation", element.getAttestation(), -1);
22868    }
22869    for (int i = 0; i < element.getValidator().size(); i++) {
22870      composeVerificationResultValidatorComponent(t, "VerificationResult", "validator", element.getValidator().get(i), i);
22871    }
22872  }
22873
22874  protected void composeVerificationResultPrimarySourceComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultPrimarySourceComponent element, int index) {
22875    if (element == null) 
22876      return;
22877    Complex t;
22878    if (Utilities.noString(parentType))
22879      t = parent;
22880    else {
22881      t = parent.predicate("fhir:"+parentType+'.'+name);
22882    }
22883    composeBackboneElement(t, "primarySource", name, element, index);
22884    if (element.hasWho()) {
22885      composeReference(t, "VerificationResultPrimarySourceComponent", "who", element.getWho(), -1);
22886    }
22887    for (int i = 0; i < element.getType().size(); i++) {
22888      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "type", element.getType().get(i), i);
22889    }
22890    for (int i = 0; i < element.getCommunicationMethod().size(); i++) {
22891      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "communicationMethod", element.getCommunicationMethod().get(i), i);
22892    }
22893    if (element.hasValidationStatus()) {
22894      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "validationStatus", element.getValidationStatus(), -1);
22895    }
22896    if (element.hasValidationDateElement()) {
22897      composeDateTime(t, "VerificationResultPrimarySourceComponent", "validationDate", element.getValidationDateElement(), -1);
22898    }
22899    if (element.hasCanPushUpdates()) {
22900      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "canPushUpdates", element.getCanPushUpdates(), -1);
22901    }
22902    for (int i = 0; i < element.getPushTypeAvailable().size(); i++) {
22903      composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "pushTypeAvailable", element.getPushTypeAvailable().get(i), i);
22904    }
22905  }
22906
22907  protected void composeVerificationResultAttestationComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultAttestationComponent element, int index) {
22908    if (element == null) 
22909      return;
22910    Complex t;
22911    if (Utilities.noString(parentType))
22912      t = parent;
22913    else {
22914      t = parent.predicate("fhir:"+parentType+'.'+name);
22915    }
22916    composeBackboneElement(t, "attestation", name, element, index);
22917    if (element.hasWho()) {
22918      composeReference(t, "VerificationResultAttestationComponent", "who", element.getWho(), -1);
22919    }
22920    if (element.hasOnBehalfOf()) {
22921      composeReference(t, "VerificationResultAttestationComponent", "onBehalfOf", element.getOnBehalfOf(), -1);
22922    }
22923    if (element.hasCommunicationMethod()) {
22924      composeCodeableConcept(t, "VerificationResultAttestationComponent", "communicationMethod", element.getCommunicationMethod(), -1);
22925    }
22926    if (element.hasDateElement()) {
22927      composeDate(t, "VerificationResultAttestationComponent", "date", element.getDateElement(), -1);
22928    }
22929    if (element.hasSourceIdentityCertificateElement()) {
22930      composeString(t, "VerificationResultAttestationComponent", "sourceIdentityCertificate", element.getSourceIdentityCertificateElement(), -1);
22931    }
22932    if (element.hasProxyIdentityCertificateElement()) {
22933      composeString(t, "VerificationResultAttestationComponent", "proxyIdentityCertificate", element.getProxyIdentityCertificateElement(), -1);
22934    }
22935    if (element.hasProxySignature()) {
22936      composeSignature(t, "VerificationResultAttestationComponent", "proxySignature", element.getProxySignature(), -1);
22937    }
22938    if (element.hasSourceSignature()) {
22939      composeSignature(t, "VerificationResultAttestationComponent", "sourceSignature", element.getSourceSignature(), -1);
22940    }
22941  }
22942
22943  protected void composeVerificationResultValidatorComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultValidatorComponent element, int index) {
22944    if (element == null) 
22945      return;
22946    Complex t;
22947    if (Utilities.noString(parentType))
22948      t = parent;
22949    else {
22950      t = parent.predicate("fhir:"+parentType+'.'+name);
22951    }
22952    composeBackboneElement(t, "validator", name, element, index);
22953    if (element.hasOrganization()) {
22954      composeReference(t, "VerificationResultValidatorComponent", "organization", element.getOrganization(), -1);
22955    }
22956    if (element.hasIdentityCertificateElement()) {
22957      composeString(t, "VerificationResultValidatorComponent", "identityCertificate", element.getIdentityCertificateElement(), -1);
22958    }
22959    if (element.hasAttestationSignature()) {
22960      composeSignature(t, "VerificationResultValidatorComponent", "attestationSignature", element.getAttestationSignature(), -1);
22961    }
22962  }
22963
22964  protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription element, int index) {
22965    if (element == null) 
22966      return;
22967    Complex t;
22968    if (Utilities.noString(parentType))
22969      t = parent;
22970    else {
22971      t = parent.predicate("fhir:"+parentType+'.'+name);
22972    }
22973    composeDomainResource(t, "VisionPrescription", name, element, index);
22974    for (int i = 0; i < element.getIdentifier().size(); i++) {
22975      composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i);
22976    }
22977    if (element.hasStatusElement()) {
22978      composeEnum(t, "VisionPrescription", "status", element.getStatusElement(), -1);
22979    }
22980    if (element.hasCreatedElement()) {
22981      composeDateTime(t, "VisionPrescription", "created", element.getCreatedElement(), -1);
22982    }
22983    if (element.hasPatient()) {
22984      composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1);
22985    }
22986    if (element.hasEncounter()) {
22987      composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1);
22988    }
22989    if (element.hasDateWrittenElement()) {
22990      composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1);
22991    }
22992    if (element.hasPrescriber()) {
22993      composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1);
22994    }
22995    for (int i = 0; i < element.getLensSpecification().size(); i++) {
22996      composeVisionPrescriptionLensSpecificationComponent(t, "VisionPrescription", "lensSpecification", element.getLensSpecification().get(i), i);
22997    }
22998  }
22999
23000  protected void composeVisionPrescriptionLensSpecificationComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionLensSpecificationComponent element, int index) {
23001    if (element == null) 
23002      return;
23003    Complex t;
23004    if (Utilities.noString(parentType))
23005      t = parent;
23006    else {
23007      t = parent.predicate("fhir:"+parentType+'.'+name);
23008    }
23009    composeBackboneElement(t, "lensSpecification", name, element, index);
23010    if (element.hasProduct()) {
23011      composeCodeableConcept(t, "VisionPrescriptionLensSpecificationComponent", "product", element.getProduct(), -1);
23012    }
23013    if (element.hasEyeElement()) {
23014      composeEnum(t, "VisionPrescriptionLensSpecificationComponent", "eye", element.getEyeElement(), -1);
23015    }
23016    if (element.hasSphereElement()) {
23017      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "sphere", element.getSphereElement(), -1);
23018    }
23019    if (element.hasCylinderElement()) {
23020      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "cylinder", element.getCylinderElement(), -1);
23021    }
23022    if (element.hasAxisElement()) {
23023      composeInteger(t, "VisionPrescriptionLensSpecificationComponent", "axis", element.getAxisElement(), -1);
23024    }
23025    for (int i = 0; i < element.getPrism().size(); i++) {
23026      composeVisionPrescriptionPrismComponent(t, "VisionPrescriptionLensSpecificationComponent", "prism", element.getPrism().get(i), i);
23027    }
23028    if (element.hasAddElement()) {
23029      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "add", element.getAddElement(), -1);
23030    }
23031    if (element.hasPowerElement()) {
23032      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "power", element.getPowerElement(), -1);
23033    }
23034    if (element.hasBackCurveElement()) {
23035      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "backCurve", element.getBackCurveElement(), -1);
23036    }
23037    if (element.hasDiameterElement()) {
23038      composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "diameter", element.getDiameterElement(), -1);
23039    }
23040    if (element.hasDuration()) {
23041      composeQuantity(t, "VisionPrescriptionLensSpecificationComponent", "duration", element.getDuration(), -1);
23042    }
23043    if (element.hasColorElement()) {
23044      composeString(t, "VisionPrescriptionLensSpecificationComponent", "color", element.getColorElement(), -1);
23045    }
23046    if (element.hasBrandElement()) {
23047      composeString(t, "VisionPrescriptionLensSpecificationComponent", "brand", element.getBrandElement(), -1);
23048    }
23049    for (int i = 0; i < element.getNote().size(); i++) {
23050      composeAnnotation(t, "VisionPrescriptionLensSpecificationComponent", "note", element.getNote().get(i), i);
23051    }
23052  }
23053
23054  protected void composeVisionPrescriptionPrismComponent(Complex parent, String parentType, String name, VisionPrescription.PrismComponent element, int index) {
23055    if (element == null) 
23056      return;
23057    Complex t;
23058    if (Utilities.noString(parentType))
23059      t = parent;
23060    else {
23061      t = parent.predicate("fhir:"+parentType+'.'+name);
23062    }
23063    composeBackboneElement(t, "prism", name, element, index);
23064    if (element.hasAmountElement()) {
23065      composeDecimal(t, "PrismComponent", "amount", element.getAmountElement(), -1);
23066    }
23067    if (element.hasBaseElement()) {
23068      composeEnum(t, "PrismComponent", "base", element.getBaseElement(), -1);
23069    }
23070  }
23071
23072
23073
23074
23075  @Override
23076  protected void composeResource(Complex parent, Resource resource) {
23077    if (parent == null) {
23078      throw new Error("parent == null");
23079    } else if (resource == null) {
23080      throw new Error("resource == null");
23081    } else if (resource instanceof Account) {
23082      composeAccount(parent, null, "Account", (Account)resource, -1);
23083    } else if (resource instanceof ActivityDefinition) {
23084      composeActivityDefinition(parent, null, "ActivityDefinition", (ActivityDefinition)resource, -1);
23085    } else if (resource instanceof AdministrableProductDefinition) {
23086      composeAdministrableProductDefinition(parent, null, "AdministrableProductDefinition", (AdministrableProductDefinition)resource, -1);
23087    } else if (resource instanceof AdverseEvent) {
23088      composeAdverseEvent(parent, null, "AdverseEvent", (AdverseEvent)resource, -1);
23089    } else if (resource instanceof AllergyIntolerance) {
23090      composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1);
23091    } else if (resource instanceof Appointment) {
23092      composeAppointment(parent, null, "Appointment", (Appointment)resource, -1);
23093    } else if (resource instanceof AppointmentResponse) {
23094      composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1);
23095    } else if (resource instanceof AuditEvent) {
23096      composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1);
23097    } else if (resource instanceof Basic) {
23098      composeBasic(parent, null, "Basic", (Basic)resource, -1);
23099    } else if (resource instanceof Binary) {
23100      composeBinary(parent, null, "Binary", (Binary)resource, -1);
23101    } else if (resource instanceof BiologicallyDerivedProduct) {
23102      composeBiologicallyDerivedProduct(parent, null, "BiologicallyDerivedProduct", (BiologicallyDerivedProduct)resource, -1);
23103    } else if (resource instanceof BodyStructure) {
23104      composeBodyStructure(parent, null, "BodyStructure", (BodyStructure)resource, -1);
23105    } else if (resource instanceof Bundle) {
23106      composeBundle(parent, null, "Bundle", (Bundle)resource, -1);
23107    } else if (resource instanceof CapabilityStatement) {
23108      composeCapabilityStatement(parent, null, "CapabilityStatement", (CapabilityStatement)resource, -1);
23109    } else if (resource instanceof CapabilityStatement2) {
23110      composeCapabilityStatement2(parent, null, "CapabilityStatement2", (CapabilityStatement2)resource, -1);
23111    } else if (resource instanceof CarePlan) {
23112      composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1);
23113    } else if (resource instanceof CareTeam) {
23114      composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1);
23115    } else if (resource instanceof CatalogEntry) {
23116      composeCatalogEntry(parent, null, "CatalogEntry", (CatalogEntry)resource, -1);
23117    } else if (resource instanceof ChargeItem) {
23118      composeChargeItem(parent, null, "ChargeItem", (ChargeItem)resource, -1);
23119    } else if (resource instanceof ChargeItemDefinition) {
23120      composeChargeItemDefinition(parent, null, "ChargeItemDefinition", (ChargeItemDefinition)resource, -1);
23121    } else if (resource instanceof Claim) {
23122      composeClaim(parent, null, "Claim", (Claim)resource, -1);
23123    } else if (resource instanceof ClaimResponse) {
23124      composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1);
23125    } else if (resource instanceof ClinicalImpression) {
23126      composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1);
23127    } else if (resource instanceof ClinicalUseIssue) {
23128      composeClinicalUseIssue(parent, null, "ClinicalUseIssue", (ClinicalUseIssue)resource, -1);
23129    } else if (resource instanceof CodeSystem) {
23130      composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1);
23131    } else if (resource instanceof Communication) {
23132      composeCommunication(parent, null, "Communication", (Communication)resource, -1);
23133    } else if (resource instanceof CommunicationRequest) {
23134      composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1);
23135    } else if (resource instanceof CompartmentDefinition) {
23136      composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1);
23137    } else if (resource instanceof Composition) {
23138      composeComposition(parent, null, "Composition", (Composition)resource, -1);
23139    } else if (resource instanceof ConceptMap) {
23140      composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1);
23141    } else if (resource instanceof Condition) {
23142      composeCondition(parent, null, "Condition", (Condition)resource, -1);
23143    } else if (resource instanceof ConditionDefinition) {
23144      composeConditionDefinition(parent, null, "ConditionDefinition", (ConditionDefinition)resource, -1);
23145    } else if (resource instanceof Consent) {
23146      composeConsent(parent, null, "Consent", (Consent)resource, -1);
23147    } else if (resource instanceof Contract) {
23148      composeContract(parent, null, "Contract", (Contract)resource, -1);
23149    } else if (resource instanceof Coverage) {
23150      composeCoverage(parent, null, "Coverage", (Coverage)resource, -1);
23151    } else if (resource instanceof CoverageEligibilityRequest) {
23152      composeCoverageEligibilityRequest(parent, null, "CoverageEligibilityRequest", (CoverageEligibilityRequest)resource, -1);
23153    } else if (resource instanceof CoverageEligibilityResponse) {
23154      composeCoverageEligibilityResponse(parent, null, "CoverageEligibilityResponse", (CoverageEligibilityResponse)resource, -1);
23155    } else if (resource instanceof DetectedIssue) {
23156      composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1);
23157    } else if (resource instanceof Device) {
23158      composeDevice(parent, null, "Device", (Device)resource, -1);
23159    } else if (resource instanceof DeviceDefinition) {
23160      composeDeviceDefinition(parent, null, "DeviceDefinition", (DeviceDefinition)resource, -1);
23161    } else if (resource instanceof DeviceMetric) {
23162      composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1);
23163    } else if (resource instanceof DeviceRequest) {
23164      composeDeviceRequest(parent, null, "DeviceRequest", (DeviceRequest)resource, -1);
23165    } else if (resource instanceof DeviceUseStatement) {
23166      composeDeviceUseStatement(parent, null, "DeviceUseStatement", (DeviceUseStatement)resource, -1);
23167    } else if (resource instanceof DiagnosticReport) {
23168      composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1);
23169    } else if (resource instanceof DocumentManifest) {
23170      composeDocumentManifest(parent, null, "DocumentManifest", (DocumentManifest)resource, -1);
23171    } else if (resource instanceof DocumentReference) {
23172      composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1);
23173    } else if (resource instanceof Encounter) {
23174      composeEncounter(parent, null, "Encounter", (Encounter)resource, -1);
23175    } else if (resource instanceof Endpoint) {
23176      composeEndpoint(parent, null, "Endpoint", (Endpoint)resource, -1);
23177    } else if (resource instanceof EnrollmentRequest) {
23178      composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1);
23179    } else if (resource instanceof EnrollmentResponse) {
23180      composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1);
23181    } else if (resource instanceof EpisodeOfCare) {
23182      composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1);
23183    } else if (resource instanceof EventDefinition) {
23184      composeEventDefinition(parent, null, "EventDefinition", (EventDefinition)resource, -1);
23185    } else if (resource instanceof Evidence) {
23186      composeEvidence(parent, null, "Evidence", (Evidence)resource, -1);
23187    } else if (resource instanceof EvidenceVariable) {
23188      composeEvidenceVariable(parent, null, "EvidenceVariable", (EvidenceVariable)resource, -1);
23189    } else if (resource instanceof ExampleScenario) {
23190      composeExampleScenario(parent, null, "ExampleScenario", (ExampleScenario)resource, -1);
23191    } else if (resource instanceof ExplanationOfBenefit) {
23192      composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1);
23193    } else if (resource instanceof FamilyMemberHistory) {
23194      composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1);
23195    } else if (resource instanceof Flag) {
23196      composeFlag(parent, null, "Flag", (Flag)resource, -1);
23197    } else if (resource instanceof Goal) {
23198      composeGoal(parent, null, "Goal", (Goal)resource, -1);
23199    } else if (resource instanceof GraphDefinition) {
23200      composeGraphDefinition(parent, null, "GraphDefinition", (GraphDefinition)resource, -1);
23201    } else if (resource instanceof Group) {
23202      composeGroup(parent, null, "Group", (Group)resource, -1);
23203    } else if (resource instanceof GuidanceResponse) {
23204      composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1);
23205    } else if (resource instanceof HealthcareService) {
23206      composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1);
23207    } else if (resource instanceof ImagingStudy) {
23208      composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1);
23209    } else if (resource instanceof Immunization) {
23210      composeImmunization(parent, null, "Immunization", (Immunization)resource, -1);
23211    } else if (resource instanceof ImmunizationEvaluation) {
23212      composeImmunizationEvaluation(parent, null, "ImmunizationEvaluation", (ImmunizationEvaluation)resource, -1);
23213    } else if (resource instanceof ImmunizationRecommendation) {
23214      composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1);
23215    } else if (resource instanceof ImplementationGuide) {
23216      composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1);
23217    } else if (resource instanceof Ingredient) {
23218      composeIngredient(parent, null, "Ingredient", (Ingredient)resource, -1);
23219    } else if (resource instanceof InsurancePlan) {
23220      composeInsurancePlan(parent, null, "InsurancePlan", (InsurancePlan)resource, -1);
23221    } else if (resource instanceof Invoice) {
23222      composeInvoice(parent, null, "Invoice", (Invoice)resource, -1);
23223    } else if (resource instanceof Library) {
23224      composeLibrary(parent, null, "Library", (Library)resource, -1);
23225    } else if (resource instanceof Linkage) {
23226      composeLinkage(parent, null, "Linkage", (Linkage)resource, -1);
23227    } else if (resource instanceof ListResource) {
23228      composeListResource(parent, null, "List", (ListResource)resource, -1);
23229    } else if (resource instanceof Location) {
23230      composeLocation(parent, null, "Location", (Location)resource, -1);
23231    } else if (resource instanceof ManufacturedItemDefinition) {
23232      composeManufacturedItemDefinition(parent, null, "ManufacturedItemDefinition", (ManufacturedItemDefinition)resource, -1);
23233    } else if (resource instanceof Measure) {
23234      composeMeasure(parent, null, "Measure", (Measure)resource, -1);
23235    } else if (resource instanceof MeasureReport) {
23236      composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1);
23237    } else if (resource instanceof Medication) {
23238      composeMedication(parent, null, "Medication", (Medication)resource, -1);
23239    } else if (resource instanceof MedicationAdministration) {
23240      composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1);
23241    } else if (resource instanceof MedicationDispense) {
23242      composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1);
23243    } else if (resource instanceof MedicationKnowledge) {
23244      composeMedicationKnowledge(parent, null, "MedicationKnowledge", (MedicationKnowledge)resource, -1);
23245    } else if (resource instanceof MedicationRequest) {
23246      composeMedicationRequest(parent, null, "MedicationRequest", (MedicationRequest)resource, -1);
23247    } else if (resource instanceof MedicationUsage) {
23248      composeMedicationUsage(parent, null, "MedicationUsage", (MedicationUsage)resource, -1);
23249    } else if (resource instanceof MedicinalProductDefinition) {
23250      composeMedicinalProductDefinition(parent, null, "MedicinalProductDefinition", (MedicinalProductDefinition)resource, -1);
23251    } else if (resource instanceof MessageDefinition) {
23252      composeMessageDefinition(parent, null, "MessageDefinition", (MessageDefinition)resource, -1);
23253    } else if (resource instanceof MessageHeader) {
23254      composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1);
23255    } else if (resource instanceof MolecularSequence) {
23256      composeMolecularSequence(parent, null, "MolecularSequence", (MolecularSequence)resource, -1);
23257    } else if (resource instanceof NamingSystem) {
23258      composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1);
23259    } else if (resource instanceof NutritionIntake) {
23260      composeNutritionIntake(parent, null, "NutritionIntake", (NutritionIntake)resource, -1);
23261    } else if (resource instanceof NutritionOrder) {
23262      composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1);
23263    } else if (resource instanceof Observation) {
23264      composeObservation(parent, null, "Observation", (Observation)resource, -1);
23265    } else if (resource instanceof ObservationDefinition) {
23266      composeObservationDefinition(parent, null, "ObservationDefinition", (ObservationDefinition)resource, -1);
23267    } else if (resource instanceof OperationDefinition) {
23268      composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1);
23269    } else if (resource instanceof OperationOutcome) {
23270      composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1);
23271    } else if (resource instanceof Organization) {
23272      composeOrganization(parent, null, "Organization", (Organization)resource, -1);
23273    } else if (resource instanceof OrganizationAffiliation) {
23274      composeOrganizationAffiliation(parent, null, "OrganizationAffiliation", (OrganizationAffiliation)resource, -1);
23275    } else if (resource instanceof PackagedProductDefinition) {
23276      composePackagedProductDefinition(parent, null, "PackagedProductDefinition", (PackagedProductDefinition)resource, -1);
23277    } else if (resource instanceof Parameters) {
23278      composeParameters(parent, null, "Parameters", (Parameters)resource, -1);
23279    } else if (resource instanceof Patient) {
23280      composePatient(parent, null, "Patient", (Patient)resource, -1);
23281    } else if (resource instanceof PaymentNotice) {
23282      composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1);
23283    } else if (resource instanceof PaymentReconciliation) {
23284      composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1);
23285    } else if (resource instanceof Person) {
23286      composePerson(parent, null, "Person", (Person)resource, -1);
23287    } else if (resource instanceof PlanDefinition) {
23288      composePlanDefinition(parent, null, "PlanDefinition", (PlanDefinition)resource, -1);
23289    } else if (resource instanceof Practitioner) {
23290      composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1);
23291    } else if (resource instanceof PractitionerRole) {
23292      composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1);
23293    } else if (resource instanceof Procedure) {
23294      composeProcedure(parent, null, "Procedure", (Procedure)resource, -1);
23295    } else if (resource instanceof Provenance) {
23296      composeProvenance(parent, null, "Provenance", (Provenance)resource, -1);
23297    } else if (resource instanceof Questionnaire) {
23298      composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1);
23299    } else if (resource instanceof QuestionnaireResponse) {
23300      composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1);
23301    } else if (resource instanceof RegulatedAuthorization) {
23302      composeRegulatedAuthorization(parent, null, "RegulatedAuthorization", (RegulatedAuthorization)resource, -1);
23303    } else if (resource instanceof RelatedPerson) {
23304      composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1);
23305    } else if (resource instanceof RequestGroup) {
23306      composeRequestGroup(parent, null, "RequestGroup", (RequestGroup)resource, -1);
23307    } else if (resource instanceof ResearchStudy) {
23308      composeResearchStudy(parent, null, "ResearchStudy", (ResearchStudy)resource, -1);
23309    } else if (resource instanceof ResearchSubject) {
23310      composeResearchSubject(parent, null, "ResearchSubject", (ResearchSubject)resource, -1);
23311    } else if (resource instanceof RiskAssessment) {
23312      composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1);
23313    } else if (resource instanceof Schedule) {
23314      composeSchedule(parent, null, "Schedule", (Schedule)resource, -1);
23315    } else if (resource instanceof SearchParameter) {
23316      composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1);
23317    } else if (resource instanceof ServiceRequest) {
23318      composeServiceRequest(parent, null, "ServiceRequest", (ServiceRequest)resource, -1);
23319    } else if (resource instanceof Slot) {
23320      composeSlot(parent, null, "Slot", (Slot)resource, -1);
23321    } else if (resource instanceof Specimen) {
23322      composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1);
23323    } else if (resource instanceof SpecimenDefinition) {
23324      composeSpecimenDefinition(parent, null, "SpecimenDefinition", (SpecimenDefinition)resource, -1);
23325    } else if (resource instanceof StructureDefinition) {
23326      composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1);
23327    } else if (resource instanceof StructureMap) {
23328      composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1);
23329    } else if (resource instanceof Subscription) {
23330      composeSubscription(parent, null, "Subscription", (Subscription)resource, -1);
23331    } else if (resource instanceof Substance) {
23332      composeSubstance(parent, null, "Substance", (Substance)resource, -1);
23333    } else if (resource instanceof SubstanceDefinition) {
23334      composeSubstanceDefinition(parent, null, "SubstanceDefinition", (SubstanceDefinition)resource, -1);
23335    } else if (resource instanceof SubstanceNucleicAcid) {
23336      composeSubstanceNucleicAcid(parent, null, "SubstanceNucleicAcid", (SubstanceNucleicAcid)resource, -1);
23337    } else if (resource instanceof SubstancePolymer) {
23338      composeSubstancePolymer(parent, null, "SubstancePolymer", (SubstancePolymer)resource, -1);
23339    } else if (resource instanceof SubstanceProtein) {
23340      composeSubstanceProtein(parent, null, "SubstanceProtein", (SubstanceProtein)resource, -1);
23341    } else if (resource instanceof SubstanceReferenceInformation) {
23342      composeSubstanceReferenceInformation(parent, null, "SubstanceReferenceInformation", (SubstanceReferenceInformation)resource, -1);
23343    } else if (resource instanceof SubstanceSourceMaterial) {
23344      composeSubstanceSourceMaterial(parent, null, "SubstanceSourceMaterial", (SubstanceSourceMaterial)resource, -1);
23345    } else if (resource instanceof SupplyDelivery) {
23346      composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1);
23347    } else if (resource instanceof SupplyRequest) {
23348      composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1);
23349    } else if (resource instanceof Task) {
23350      composeTask(parent, null, "Task", (Task)resource, -1);
23351    } else if (resource instanceof TerminologyCapabilities) {
23352      composeTerminologyCapabilities(parent, null, "TerminologyCapabilities", (TerminologyCapabilities)resource, -1);
23353    } else if (resource instanceof TestReport) {
23354      composeTestReport(parent, null, "TestReport", (TestReport)resource, -1);
23355    } else if (resource instanceof TestScript) {
23356      composeTestScript(parent, null, "TestScript", (TestScript)resource, -1);
23357    } else if (resource instanceof Topic) {
23358      composeTopic(parent, null, "Topic", (Topic)resource, -1);
23359    } else if (resource instanceof ValueSet) {
23360      composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1);
23361    } else if (resource instanceof VerificationResult) {
23362      composeVerificationResult(parent, null, "VerificationResult", (VerificationResult)resource, -1);
23363    } else if (resource instanceof VisionPrescription) {
23364      composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1);
23365      
23366    } else {
23367      throw new Error("Unhandled resource type "+resource.getClass().getName());
23368    }
23369  }
23370
23371  protected void composeType(Complex parent, String parentType, String name, DataType value, int index) {
23372    if (parent == null) {
23373      throw new Error("parent == null");
23374    } else if (parentType == null) {
23375      throw new Error("parentType == null");
23376    } else if (name == null) {
23377      throw new Error("name == null");
23378    } else if (value == null) {
23379      throw new Error("value == null");
23380    } else if (value instanceof DateType) {
23381      composeDate(parent, parentType, name, (DateType)value, index);
23382    } else if (value instanceof DateTimeType) {
23383      composeDateTime(parent, parentType, name, (DateTimeType)value, index);
23384    } else if (value instanceof CodeType) {
23385      composeCode(parent, parentType, name, (CodeType)value, index);
23386    } else if (value instanceof StringType) {
23387      composeString(parent, parentType, name, (StringType)value, index);
23388    } else if (value instanceof IntegerType) {
23389      composeInteger(parent, parentType, name, (IntegerType)value, index);
23390    } else if (value instanceof Integer64Type) {
23391      composeInteger64(parent, parentType, name, (Integer64Type)value, index);
23392    } else if (value instanceof OidType) {
23393      composeOid(parent, parentType, name, (OidType)value, index);
23394    } else if (value instanceof CanonicalType) {
23395      composeCanonical(parent, parentType, name, (CanonicalType)value, index);
23396    } else if (value instanceof UriType) {
23397      composeUri(parent, parentType, name, (UriType)value, index);
23398    } else if (value instanceof UuidType) {
23399      composeUuid(parent, parentType, name, (UuidType)value, index);
23400    } else if (value instanceof UrlType) {
23401      composeUrl(parent, parentType, name, (UrlType)value, index);
23402    } else if (value instanceof InstantType) {
23403      composeInstant(parent, parentType, name, (InstantType)value, index);
23404    } else if (value instanceof BooleanType) {
23405      composeBoolean(parent, parentType, name, (BooleanType)value, index);
23406    } else if (value instanceof Base64BinaryType) {
23407      composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index);
23408    } else if (value instanceof UnsignedIntType) {
23409      composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index);
23410    } else if (value instanceof MarkdownType) {
23411      composeMarkdown(parent, parentType, name, (MarkdownType)value, index);
23412    } else if (value instanceof TimeType) {
23413      composeTime(parent, parentType, name, (TimeType)value, index);
23414    } else if (value instanceof IdType) {
23415      composeId(parent, parentType, name, (IdType)value, index);
23416    } else if (value instanceof PositiveIntType) {
23417      composePositiveInt(parent, parentType, name, (PositiveIntType)value, index);
23418    } else if (value instanceof DecimalType) {
23419      composeDecimal(parent, parentType, name, (DecimalType)value, index);
23420    } else if (value instanceof Address) {
23421      composeAddress(parent, parentType, name, (Address)value, index);
23422    } else if (value instanceof Age) {
23423      composeAge(parent, parentType, name, (Age)value, index);
23424    } else if (value instanceof Annotation) {
23425      composeAnnotation(parent, parentType, name, (Annotation)value, index);
23426    } else if (value instanceof Attachment) {
23427      composeAttachment(parent, parentType, name, (Attachment)value, index);
23428    } else if (value instanceof CodeableConcept) {
23429      composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index);
23430    } else if (value instanceof CodeableReference) {
23431      composeCodeableReference(parent, parentType, name, (CodeableReference)value, index);
23432    } else if (value instanceof Coding) {
23433      composeCoding(parent, parentType, name, (Coding)value, index);
23434    } else if (value instanceof ContactDetail) {
23435      composeContactDetail(parent, parentType, name, (ContactDetail)value, index);
23436    } else if (value instanceof ContactPoint) {
23437      composeContactPoint(parent, parentType, name, (ContactPoint)value, index);
23438    } else if (value instanceof Contributor) {
23439      composeContributor(parent, parentType, name, (Contributor)value, index);
23440    } else if (value instanceof Count) {
23441      composeCount(parent, parentType, name, (Count)value, index);
23442    } else if (value instanceof DataRequirement) {
23443      composeDataRequirement(parent, parentType, name, (DataRequirement)value, index);
23444    } else if (value instanceof Distance) {
23445      composeDistance(parent, parentType, name, (Distance)value, index);
23446    } else if (value instanceof Dosage) {
23447      composeDosage(parent, parentType, name, (Dosage)value, index);
23448    } else if (value instanceof Duration) {
23449      composeDuration(parent, parentType, name, (Duration)value, index);
23450    } else if (value instanceof ElementDefinition) {
23451      composeElementDefinition(parent, parentType, name, (ElementDefinition)value, index);
23452    } else if (value instanceof Expression) {
23453      composeExpression(parent, parentType, name, (Expression)value, index);
23454    } else if (value instanceof Extension) {
23455      composeExtension(parent, parentType, name, (Extension)value, index);
23456    } else if (value instanceof HumanName) {
23457      composeHumanName(parent, parentType, name, (HumanName)value, index);
23458    } else if (value instanceof Identifier) {
23459      composeIdentifier(parent, parentType, name, (Identifier)value, index);
23460    } else if (value instanceof MarketingStatus) {
23461      composeMarketingStatus(parent, parentType, name, (MarketingStatus)value, index);
23462    } else if (value instanceof Meta) {
23463      composeMeta(parent, parentType, name, (Meta)value, index);
23464    } else if (value instanceof Money) {
23465      composeMoney(parent, parentType, name, (Money)value, index);
23466    } else if (value instanceof Narrative) {
23467      composeNarrative(parent, parentType, name, (Narrative)value, index);
23468    } else if (value instanceof OrderedDistribution) {
23469      composeOrderedDistribution(parent, parentType, name, (OrderedDistribution)value, index);
23470    } else if (value instanceof ParameterDefinition) {
23471      composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index);
23472    } else if (value instanceof Period) {
23473      composePeriod(parent, parentType, name, (Period)value, index);
23474    } else if (value instanceof Population) {
23475      composePopulation(parent, parentType, name, (Population)value, index);
23476    } else if (value instanceof ProdCharacteristic) {
23477      composeProdCharacteristic(parent, parentType, name, (ProdCharacteristic)value, index);
23478    } else if (value instanceof ProductShelfLife) {
23479      composeProductShelfLife(parent, parentType, name, (ProductShelfLife)value, index);
23480    } else if (value instanceof Quantity) {
23481      composeQuantity(parent, parentType, name, (Quantity)value, index);
23482    } else if (value instanceof Range) {
23483      composeRange(parent, parentType, name, (Range)value, index);
23484    } else if (value instanceof Ratio) {
23485      composeRatio(parent, parentType, name, (Ratio)value, index);
23486    } else if (value instanceof Reference) {
23487      composeReference(parent, parentType, name, (Reference)value, index);
23488    } else if (value instanceof RelatedArtifact) {
23489      composeRelatedArtifact(parent, parentType, name, (RelatedArtifact)value, index);
23490    } else if (value instanceof SampledData) {
23491      composeSampledData(parent, parentType, name, (SampledData)value, index);
23492    } else if (value instanceof Signature) {
23493      composeSignature(parent, parentType, name, (Signature)value, index);
23494    } else if (value instanceof Statistic) {
23495      composeStatistic(parent, parentType, name, (Statistic)value, index);
23496    } else if (value instanceof SubstanceAmount) {
23497      composeSubstanceAmount(parent, parentType, name, (SubstanceAmount)value, index);
23498    } else if (value instanceof Timing) {
23499      composeTiming(parent, parentType, name, (Timing)value, index);
23500    } else if (value instanceof TriggerDefinition) {
23501      composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index);
23502    } else if (value instanceof UsageContext) {
23503      composeUsageContext(parent, parentType, name, (UsageContext)value, index);
23504      
23505    } else {
23506      throw new Error("Unhandled type");
23507    }
23508  }
23509
23510}
23511