001package org.hl7.fhir.r5.model;
002
003
004/*
005  Copyright (c) 2011+, HL7, Inc.
006  All rights reserved.
007  
008  Redistribution and use in source and binary forms, with or without modification, \
009  are permitted provided that the following conditions are met:
010  
011   * Redistributions of source code must retain the above copyright notice, this \
012     list of conditions and the following disclaimer.
013   * Redistributions in binary form must reproduce the above copyright notice, \
014     this list of conditions and the following disclaimer in the documentation \
015     and/or other materials provided with the distribution.
016   * Neither the name of HL7 nor the names of its contributors may be used to 
017     endorse or promote products derived from this software without specific 
018     prior written permission.
019  
020  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
021  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
022  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
023  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
024  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
025  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
026  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
027  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
028  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
029  POSSIBILITY OF SUCH DAMAGE.
030  */
031
032// Generated on Sat, Nov 5, 2022 10:47+1100 for FHIR v5.0.0-ballot
033
034import java.util.ArrayList;
035import java.util.Date;
036import java.util.List;
037import org.hl7.fhir.utilities.Utilities;
038import org.hl7.fhir.r5.model.Enumerations.*;
039import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
040import org.hl7.fhir.exceptions.FHIRException;
041import org.hl7.fhir.instance.model.api.ICompositeType;
042import ca.uhn.fhir.model.api.annotation.ResourceDef;
043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
044import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
045import ca.uhn.fhir.model.api.annotation.Child;
046import ca.uhn.fhir.model.api.annotation.ChildOrder;
047import ca.uhn.fhir.model.api.annotation.Description;
048import ca.uhn.fhir.model.api.annotation.Block;
049
050import org.hl7.fhir.r5.utils.structuremap.StructureMapUtilities;
051/**
052 * A Map of relationships between 2 structures that can be used to transform data.
053 */
054@ResourceDef(name="StructureMap", profile="http://hl7.org/fhir/StructureDefinition/StructureMap")
055public class StructureMap extends CanonicalResource {
056
057    public enum StructureMapGroupTypeMode {
058        /**
059         * This group is a default mapping group for the specified types and for the primary source type.
060         */
061        TYPES, 
062        /**
063         * This group is a default mapping group for the specified types.
064         */
065        TYPEANDTYPES, 
066        /**
067         * added to help the parsers with the generic types
068         */
069        NULL;
070        public static StructureMapGroupTypeMode fromCode(String codeString) throws FHIRException {
071            if (codeString == null || "".equals(codeString))
072                return null;
073        if ("types".equals(codeString))
074          return TYPES;
075        if ("type-and-types".equals(codeString))
076          return TYPEANDTYPES;
077        if (Configuration.isAcceptInvalidEnums())
078          return null;
079        else
080          throw new FHIRException("Unknown StructureMapGroupTypeMode code '"+codeString+"'");
081        }
082        public String toCode() {
083          switch (this) {
084            case TYPES: return "types";
085            case TYPEANDTYPES: return "type-and-types";
086            case NULL: return null;
087            default: return "?";
088          }
089        }
090        public String getSystem() {
091          switch (this) {
092            case TYPES: return "http://hl7.org/fhir/map-group-type-mode";
093            case TYPEANDTYPES: return "http://hl7.org/fhir/map-group-type-mode";
094            case NULL: return null;
095            default: return "?";
096          }
097        }
098        public String getDefinition() {
099          switch (this) {
100            case TYPES: return "This group is a default mapping group for the specified types and for the primary source type.";
101            case TYPEANDTYPES: return "This group is a default mapping group for the specified types.";
102            case NULL: return null;
103            default: return "?";
104          }
105        }
106        public String getDisplay() {
107          switch (this) {
108            case TYPES: return "Default for Type Combination";
109            case TYPEANDTYPES: return "Default for type + combination";
110            case NULL: return null;
111            default: return "?";
112          }
113        }
114    }
115
116  public static class StructureMapGroupTypeModeEnumFactory implements EnumFactory<StructureMapGroupTypeMode> {
117    public StructureMapGroupTypeMode fromCode(String codeString) throws IllegalArgumentException {
118      if (codeString == null || "".equals(codeString))
119            if (codeString == null || "".equals(codeString))
120                return null;
121        if ("types".equals(codeString))
122          return StructureMapGroupTypeMode.TYPES;
123        if ("type-and-types".equals(codeString))
124          return StructureMapGroupTypeMode.TYPEANDTYPES;
125        throw new IllegalArgumentException("Unknown StructureMapGroupTypeMode code '"+codeString+"'");
126        }
127        public Enumeration<StructureMapGroupTypeMode> fromType(Base code) throws FHIRException {
128          if (code == null)
129            return null;
130          if (code.isEmpty())
131            return new Enumeration<StructureMapGroupTypeMode>(this);
132          String codeString = ((PrimitiveType) code).asStringValue();
133          if (codeString == null || "".equals(codeString))
134            return null;
135        if ("types".equals(codeString))
136          return new Enumeration<StructureMapGroupTypeMode>(this, StructureMapGroupTypeMode.TYPES);
137        if ("type-and-types".equals(codeString))
138          return new Enumeration<StructureMapGroupTypeMode>(this, StructureMapGroupTypeMode.TYPEANDTYPES);
139        throw new FHIRException("Unknown StructureMapGroupTypeMode code '"+codeString+"'");
140        }
141    public String toCode(StructureMapGroupTypeMode code) {
142      if (code == StructureMapGroupTypeMode.TYPES)
143        return "types";
144      if (code == StructureMapGroupTypeMode.TYPEANDTYPES)
145        return "type-and-types";
146      return "?";
147      }
148    public String toSystem(StructureMapGroupTypeMode code) {
149      return code.getSystem();
150      }
151    }
152
153    public enum StructureMapInputMode {
154        /**
155         * Names an input instance used a source for mapping.
156         */
157        SOURCE, 
158        /**
159         * Names an instance that is being populated.
160         */
161        TARGET, 
162        /**
163         * added to help the parsers with the generic types
164         */
165        NULL;
166        public static StructureMapInputMode fromCode(String codeString) throws FHIRException {
167            if (codeString == null || "".equals(codeString))
168                return null;
169        if ("source".equals(codeString))
170          return SOURCE;
171        if ("target".equals(codeString))
172          return TARGET;
173        if (Configuration.isAcceptInvalidEnums())
174          return null;
175        else
176          throw new FHIRException("Unknown StructureMapInputMode code '"+codeString+"'");
177        }
178        public String toCode() {
179          switch (this) {
180            case SOURCE: return "source";
181            case TARGET: return "target";
182            case NULL: return null;
183            default: return "?";
184          }
185        }
186        public String getSystem() {
187          switch (this) {
188            case SOURCE: return "http://hl7.org/fhir/map-input-mode";
189            case TARGET: return "http://hl7.org/fhir/map-input-mode";
190            case NULL: return null;
191            default: return "?";
192          }
193        }
194        public String getDefinition() {
195          switch (this) {
196            case SOURCE: return "Names an input instance used a source for mapping.";
197            case TARGET: return "Names an instance that is being populated.";
198            case NULL: return null;
199            default: return "?";
200          }
201        }
202        public String getDisplay() {
203          switch (this) {
204            case SOURCE: return "Source Instance";
205            case TARGET: return "Target Instance";
206            case NULL: return null;
207            default: return "?";
208          }
209        }
210    }
211
212  public static class StructureMapInputModeEnumFactory implements EnumFactory<StructureMapInputMode> {
213    public StructureMapInputMode fromCode(String codeString) throws IllegalArgumentException {
214      if (codeString == null || "".equals(codeString))
215            if (codeString == null || "".equals(codeString))
216                return null;
217        if ("source".equals(codeString))
218          return StructureMapInputMode.SOURCE;
219        if ("target".equals(codeString))
220          return StructureMapInputMode.TARGET;
221        throw new IllegalArgumentException("Unknown StructureMapInputMode code '"+codeString+"'");
222        }
223        public Enumeration<StructureMapInputMode> fromType(Base code) throws FHIRException {
224          if (code == null)
225            return null;
226          if (code.isEmpty())
227            return new Enumeration<StructureMapInputMode>(this);
228          String codeString = ((PrimitiveType) code).asStringValue();
229          if (codeString == null || "".equals(codeString))
230            return null;
231        if ("source".equals(codeString))
232          return new Enumeration<StructureMapInputMode>(this, StructureMapInputMode.SOURCE);
233        if ("target".equals(codeString))
234          return new Enumeration<StructureMapInputMode>(this, StructureMapInputMode.TARGET);
235        throw new FHIRException("Unknown StructureMapInputMode code '"+codeString+"'");
236        }
237    public String toCode(StructureMapInputMode code) {
238      if (code == StructureMapInputMode.SOURCE)
239        return "source";
240      if (code == StructureMapInputMode.TARGET)
241        return "target";
242      return "?";
243      }
244    public String toSystem(StructureMapInputMode code) {
245      return code.getSystem();
246      }
247    }
248
249    public enum StructureMapModelMode {
250        /**
251         * This structure describes an instance passed to the mapping engine that is used a source of data.
252         */
253        SOURCE, 
254        /**
255         * This structure describes an instance that the mapping engine may ask for that is used a source of data.
256         */
257        QUERIED, 
258        /**
259         * This structure describes an instance passed to the mapping engine that is used a target of data.
260         */
261        TARGET, 
262        /**
263         * This structure describes an instance that the mapping engine may ask to create that is used a target of data.
264         */
265        PRODUCED, 
266        /**
267         * added to help the parsers with the generic types
268         */
269        NULL;
270        public static StructureMapModelMode fromCode(String codeString) throws FHIRException {
271            if (codeString == null || "".equals(codeString))
272                return null;
273        if ("source".equals(codeString))
274          return SOURCE;
275        if ("queried".equals(codeString))
276          return QUERIED;
277        if ("target".equals(codeString))
278          return TARGET;
279        if ("produced".equals(codeString))
280          return PRODUCED;
281        if (Configuration.isAcceptInvalidEnums())
282          return null;
283        else
284          throw new FHIRException("Unknown StructureMapModelMode code '"+codeString+"'");
285        }
286        public String toCode() {
287          switch (this) {
288            case SOURCE: return "source";
289            case QUERIED: return "queried";
290            case TARGET: return "target";
291            case PRODUCED: return "produced";
292            case NULL: return null;
293            default: return "?";
294          }
295        }
296        public String getSystem() {
297          switch (this) {
298            case SOURCE: return "http://hl7.org/fhir/map-model-mode";
299            case QUERIED: return "http://hl7.org/fhir/map-model-mode";
300            case TARGET: return "http://hl7.org/fhir/map-model-mode";
301            case PRODUCED: return "http://hl7.org/fhir/map-model-mode";
302            case NULL: return null;
303            default: return "?";
304          }
305        }
306        public String getDefinition() {
307          switch (this) {
308            case SOURCE: return "This structure describes an instance passed to the mapping engine that is used a source of data.";
309            case QUERIED: return "This structure describes an instance that the mapping engine may ask for that is used a source of data.";
310            case TARGET: return "This structure describes an instance passed to the mapping engine that is used a target of data.";
311            case PRODUCED: return "This structure describes an instance that the mapping engine may ask to create that is used a target of data.";
312            case NULL: return null;
313            default: return "?";
314          }
315        }
316        public String getDisplay() {
317          switch (this) {
318            case SOURCE: return "Source Structure Definition";
319            case QUERIED: return "Queried Structure Definition";
320            case TARGET: return "Target Structure Definition";
321            case PRODUCED: return "Produced Structure Definition";
322            case NULL: return null;
323            default: return "?";
324          }
325        }
326    }
327
328  public static class StructureMapModelModeEnumFactory implements EnumFactory<StructureMapModelMode> {
329    public StructureMapModelMode fromCode(String codeString) throws IllegalArgumentException {
330      if (codeString == null || "".equals(codeString))
331            if (codeString == null || "".equals(codeString))
332                return null;
333        if ("source".equals(codeString))
334          return StructureMapModelMode.SOURCE;
335        if ("queried".equals(codeString))
336          return StructureMapModelMode.QUERIED;
337        if ("target".equals(codeString))
338          return StructureMapModelMode.TARGET;
339        if ("produced".equals(codeString))
340          return StructureMapModelMode.PRODUCED;
341        throw new IllegalArgumentException("Unknown StructureMapModelMode code '"+codeString+"'");
342        }
343        public Enumeration<StructureMapModelMode> fromType(Base code) throws FHIRException {
344          if (code == null)
345            return null;
346          if (code.isEmpty())
347            return new Enumeration<StructureMapModelMode>(this);
348          String codeString = ((PrimitiveType) code).asStringValue();
349          if (codeString == null || "".equals(codeString))
350            return null;
351        if ("source".equals(codeString))
352          return new Enumeration<StructureMapModelMode>(this, StructureMapModelMode.SOURCE);
353        if ("queried".equals(codeString))
354          return new Enumeration<StructureMapModelMode>(this, StructureMapModelMode.QUERIED);
355        if ("target".equals(codeString))
356          return new Enumeration<StructureMapModelMode>(this, StructureMapModelMode.TARGET);
357        if ("produced".equals(codeString))
358          return new Enumeration<StructureMapModelMode>(this, StructureMapModelMode.PRODUCED);
359        throw new FHIRException("Unknown StructureMapModelMode code '"+codeString+"'");
360        }
361    public String toCode(StructureMapModelMode code) {
362      if (code == StructureMapModelMode.SOURCE)
363        return "source";
364      if (code == StructureMapModelMode.QUERIED)
365        return "queried";
366      if (code == StructureMapModelMode.TARGET)
367        return "target";
368      if (code == StructureMapModelMode.PRODUCED)
369        return "produced";
370      return "?";
371      }
372    public String toSystem(StructureMapModelMode code) {
373      return code.getSystem();
374      }
375    }
376
377    public enum StructureMapSourceListMode {
378        /**
379         * Only process this rule for the first in the list.
380         */
381        FIRST, 
382        /**
383         * Process this rule for all but the first.
384         */
385        NOTFIRST, 
386        /**
387         * Only process this rule for the last in the list.
388         */
389        LAST, 
390        /**
391         * Process this rule for all but the last.
392         */
393        NOTLAST, 
394        /**
395         * Only process this rule is there is only item.
396         */
397        ONLYONE, 
398        /**
399         * added to help the parsers with the generic types
400         */
401        NULL;
402        public static StructureMapSourceListMode fromCode(String codeString) throws FHIRException {
403            if (codeString == null || "".equals(codeString))
404                return null;
405        if ("first".equals(codeString))
406          return FIRST;
407        if ("not_first".equals(codeString))
408          return NOTFIRST;
409        if ("last".equals(codeString))
410          return LAST;
411        if ("not_last".equals(codeString))
412          return NOTLAST;
413        if ("only_one".equals(codeString))
414          return ONLYONE;
415        if (Configuration.isAcceptInvalidEnums())
416          return null;
417        else
418          throw new FHIRException("Unknown StructureMapSourceListMode code '"+codeString+"'");
419        }
420        public String toCode() {
421          switch (this) {
422            case FIRST: return "first";
423            case NOTFIRST: return "not_first";
424            case LAST: return "last";
425            case NOTLAST: return "not_last";
426            case ONLYONE: return "only_one";
427            case NULL: return null;
428            default: return "?";
429          }
430        }
431        public String getSystem() {
432          switch (this) {
433            case FIRST: return "http://hl7.org/fhir/map-source-list-mode";
434            case NOTFIRST: return "http://hl7.org/fhir/map-source-list-mode";
435            case LAST: return "http://hl7.org/fhir/map-source-list-mode";
436            case NOTLAST: return "http://hl7.org/fhir/map-source-list-mode";
437            case ONLYONE: return "http://hl7.org/fhir/map-source-list-mode";
438            case NULL: return null;
439            default: return "?";
440          }
441        }
442        public String getDefinition() {
443          switch (this) {
444            case FIRST: return "Only process this rule for the first in the list.";
445            case NOTFIRST: return "Process this rule for all but the first.";
446            case LAST: return "Only process this rule for the last in the list.";
447            case NOTLAST: return "Process this rule for all but the last.";
448            case ONLYONE: return "Only process this rule is there is only item.";
449            case NULL: return null;
450            default: return "?";
451          }
452        }
453        public String getDisplay() {
454          switch (this) {
455            case FIRST: return "First";
456            case NOTFIRST: return "All but the first";
457            case LAST: return "Last";
458            case NOTLAST: return "All but the last";
459            case ONLYONE: return "Enforce only one";
460            case NULL: return null;
461            default: return "?";
462          }
463        }
464    }
465
466  public static class StructureMapSourceListModeEnumFactory implements EnumFactory<StructureMapSourceListMode> {
467    public StructureMapSourceListMode fromCode(String codeString) throws IllegalArgumentException {
468      if (codeString == null || "".equals(codeString))
469            if (codeString == null || "".equals(codeString))
470                return null;
471        if ("first".equals(codeString))
472          return StructureMapSourceListMode.FIRST;
473        if ("not_first".equals(codeString))
474          return StructureMapSourceListMode.NOTFIRST;
475        if ("last".equals(codeString))
476          return StructureMapSourceListMode.LAST;
477        if ("not_last".equals(codeString))
478          return StructureMapSourceListMode.NOTLAST;
479        if ("only_one".equals(codeString))
480          return StructureMapSourceListMode.ONLYONE;
481        throw new IllegalArgumentException("Unknown StructureMapSourceListMode code '"+codeString+"'");
482        }
483        public Enumeration<StructureMapSourceListMode> fromType(Base code) throws FHIRException {
484          if (code == null)
485            return null;
486          if (code.isEmpty())
487            return new Enumeration<StructureMapSourceListMode>(this);
488          String codeString = ((PrimitiveType) code).asStringValue();
489          if (codeString == null || "".equals(codeString))
490            return null;
491        if ("first".equals(codeString))
492          return new Enumeration<StructureMapSourceListMode>(this, StructureMapSourceListMode.FIRST);
493        if ("not_first".equals(codeString))
494          return new Enumeration<StructureMapSourceListMode>(this, StructureMapSourceListMode.NOTFIRST);
495        if ("last".equals(codeString))
496          return new Enumeration<StructureMapSourceListMode>(this, StructureMapSourceListMode.LAST);
497        if ("not_last".equals(codeString))
498          return new Enumeration<StructureMapSourceListMode>(this, StructureMapSourceListMode.NOTLAST);
499        if ("only_one".equals(codeString))
500          return new Enumeration<StructureMapSourceListMode>(this, StructureMapSourceListMode.ONLYONE);
501        throw new FHIRException("Unknown StructureMapSourceListMode code '"+codeString+"'");
502        }
503    public String toCode(StructureMapSourceListMode code) {
504      if (code == StructureMapSourceListMode.FIRST)
505        return "first";
506      if (code == StructureMapSourceListMode.NOTFIRST)
507        return "not_first";
508      if (code == StructureMapSourceListMode.LAST)
509        return "last";
510      if (code == StructureMapSourceListMode.NOTLAST)
511        return "not_last";
512      if (code == StructureMapSourceListMode.ONLYONE)
513        return "only_one";
514      return "?";
515      }
516    public String toSystem(StructureMapSourceListMode code) {
517      return code.getSystem();
518      }
519    }
520
521    public enum StructureMapTargetListMode {
522        /**
523         * when the target list is being assembled, the items for this rule go first. If more than one rule defines a first item (for a given instance of mapping) then this is an error.
524         */
525        FIRST, 
526        /**
527         * the target instance is shared with the target instances generated by another rule (up to the first common n items, then create new ones).
528         */
529        SHARE, 
530        /**
531         * when the target list is being assembled, the items for this rule go last. If more than one rule defines a last item (for a given instance of mapping) then this is an error.
532         */
533        LAST, 
534        /**
535         * re-use the first item in the list, and keep adding content to it.
536         */
537        COLLATE, 
538        /**
539         * added to help the parsers with the generic types
540         */
541        NULL;
542        public static StructureMapTargetListMode fromCode(String codeString) throws FHIRException {
543            if (codeString == null || "".equals(codeString))
544                return null;
545        if ("first".equals(codeString))
546          return FIRST;
547        if ("share".equals(codeString))
548          return SHARE;
549        if ("last".equals(codeString))
550          return LAST;
551        if ("collate".equals(codeString))
552          return COLLATE;
553        if (Configuration.isAcceptInvalidEnums())
554          return null;
555        else
556          throw new FHIRException("Unknown StructureMapTargetListMode code '"+codeString+"'");
557        }
558        public String toCode() {
559          switch (this) {
560            case FIRST: return "first";
561            case SHARE: return "share";
562            case LAST: return "last";
563            case COLLATE: return "collate";
564            case NULL: return null;
565            default: return "?";
566          }
567        }
568        public String getSystem() {
569          switch (this) {
570            case FIRST: return "http://hl7.org/fhir/map-target-list-mode";
571            case SHARE: return "http://hl7.org/fhir/map-target-list-mode";
572            case LAST: return "http://hl7.org/fhir/map-target-list-mode";
573            case COLLATE: return "http://hl7.org/fhir/map-target-list-mode";
574            case NULL: return null;
575            default: return "?";
576          }
577        }
578        public String getDefinition() {
579          switch (this) {
580            case FIRST: return "when the target list is being assembled, the items for this rule go first. If more than one rule defines a first item (for a given instance of mapping) then this is an error.";
581            case SHARE: return "the target instance is shared with the target instances generated by another rule (up to the first common n items, then create new ones).";
582            case LAST: return "when the target list is being assembled, the items for this rule go last. If more than one rule defines a last item (for a given instance of mapping) then this is an error.";
583            case COLLATE: return "re-use the first item in the list, and keep adding content to it.";
584            case NULL: return null;
585            default: return "?";
586          }
587        }
588        public String getDisplay() {
589          switch (this) {
590            case FIRST: return "First";
591            case SHARE: return "Share";
592            case LAST: return "Last";
593            case COLLATE: return "Collate";
594            case NULL: return null;
595            default: return "?";
596          }
597        }
598    }
599
600  public static class StructureMapTargetListModeEnumFactory implements EnumFactory<StructureMapTargetListMode> {
601    public StructureMapTargetListMode fromCode(String codeString) throws IllegalArgumentException {
602      if (codeString == null || "".equals(codeString))
603            if (codeString == null || "".equals(codeString))
604                return null;
605        if ("first".equals(codeString))
606          return StructureMapTargetListMode.FIRST;
607        if ("share".equals(codeString))
608          return StructureMapTargetListMode.SHARE;
609        if ("last".equals(codeString))
610          return StructureMapTargetListMode.LAST;
611        if ("collate".equals(codeString))
612          return StructureMapTargetListMode.COLLATE;
613        throw new IllegalArgumentException("Unknown StructureMapTargetListMode code '"+codeString+"'");
614        }
615        public Enumeration<StructureMapTargetListMode> fromType(Base code) throws FHIRException {
616          if (code == null)
617            return null;
618          if (code.isEmpty())
619            return new Enumeration<StructureMapTargetListMode>(this);
620          String codeString = ((PrimitiveType) code).asStringValue();
621          if (codeString == null || "".equals(codeString))
622            return null;
623        if ("first".equals(codeString))
624          return new Enumeration<StructureMapTargetListMode>(this, StructureMapTargetListMode.FIRST);
625        if ("share".equals(codeString))
626          return new Enumeration<StructureMapTargetListMode>(this, StructureMapTargetListMode.SHARE);
627        if ("last".equals(codeString))
628          return new Enumeration<StructureMapTargetListMode>(this, StructureMapTargetListMode.LAST);
629        if ("collate".equals(codeString))
630          return new Enumeration<StructureMapTargetListMode>(this, StructureMapTargetListMode.COLLATE);
631        throw new FHIRException("Unknown StructureMapTargetListMode code '"+codeString+"'");
632        }
633    public String toCode(StructureMapTargetListMode code) {
634      if (code == StructureMapTargetListMode.FIRST)
635        return "first";
636      if (code == StructureMapTargetListMode.SHARE)
637        return "share";
638      if (code == StructureMapTargetListMode.LAST)
639        return "last";
640      if (code == StructureMapTargetListMode.COLLATE)
641        return "collate";
642      return "?";
643      }
644    public String toSystem(StructureMapTargetListMode code) {
645      return code.getSystem();
646      }
647    }
648
649    public enum StructureMapTransform {
650        /**
651         * create(type : string) - type is passed through to the application on the standard API, and must be known by it.
652         */
653        CREATE, 
654        /**
655         * copy(source).
656         */
657        COPY, 
658        /**
659         * truncate(source, length) - source must be stringy type.
660         */
661        TRUNCATE, 
662        /**
663         * escape(source, fmt1, fmt2) - change source from one kind of escaping to another (plain, java, xml, json). note that this is for when the string itself is escaped.
664         */
665        ESCAPE, 
666        /**
667         * cast(source, type?) - case source from one type to another. target type can be left as implicit if there is one and only one target type known.
668         */
669        CAST, 
670        /**
671         * append(source...) - source is element or string.
672         */
673        APPEND, 
674        /**
675         * translate(source, uri_of_map) - use the translate operation.
676         */
677        TRANSLATE, 
678        /**
679         * reference(source : object) - return a string that references the provided tree properly.
680         */
681        REFERENCE, 
682        /**
683         * Perform a date operation. *Parameters to be documented*.
684         */
685        DATEOP, 
686        /**
687         * Generate a random UUID (in lowercase). No Parameters.
688         */
689        UUID, 
690        /**
691         * Return the appropriate string to put in a reference that refers to the resource provided as a parameter.
692         */
693        POINTER, 
694        /**
695         * Execute the supplied FHIRPath expression and use the value returned by that.
696         */
697        EVALUATE, 
698        /**
699         * Create a CodeableConcept. Parameters = (text) or (system. Code[, display]).
700         */
701        CC, 
702        /**
703         * Create a Coding. Parameters = (system. Code[, display]).
704         */
705        C, 
706        /**
707         * Create a quantity. Parameters = (text) or (value, unit, [system, code]) where text is the natural representation e.g. [comparator]value[space]unit.
708         */
709        QTY, 
710        /**
711         * Create an identifier. Parameters = (system, value[, type]) where type is a code from the identifier type value set.
712         */
713        ID, 
714        /**
715         * Create a contact details. Parameters = (value) or (system, value). If no system is provided, the system should be inferred from the content of the value.
716         */
717        CP, 
718        /**
719         * added to help the parsers with the generic types
720         */
721        NULL;
722        public static StructureMapTransform fromCode(String codeString) throws FHIRException {
723            if (codeString == null || "".equals(codeString))
724                return null;
725        if ("create".equals(codeString))
726          return CREATE;
727        if ("copy".equals(codeString))
728          return COPY;
729        if ("truncate".equals(codeString))
730          return TRUNCATE;
731        if ("escape".equals(codeString))
732          return ESCAPE;
733        if ("cast".equals(codeString))
734          return CAST;
735        if ("append".equals(codeString))
736          return APPEND;
737        if ("translate".equals(codeString))
738          return TRANSLATE;
739        if ("reference".equals(codeString))
740          return REFERENCE;
741        if ("dateOp".equals(codeString))
742          return DATEOP;
743        if ("uuid".equals(codeString))
744          return UUID;
745        if ("pointer".equals(codeString))
746          return POINTER;
747        if ("evaluate".equals(codeString))
748          return EVALUATE;
749        if ("cc".equals(codeString))
750          return CC;
751        if ("c".equals(codeString))
752          return C;
753        if ("qty".equals(codeString))
754          return QTY;
755        if ("id".equals(codeString))
756          return ID;
757        if ("cp".equals(codeString))
758          return CP;
759        if (Configuration.isAcceptInvalidEnums())
760          return null;
761        else
762          throw new FHIRException("Unknown StructureMapTransform code '"+codeString+"'");
763        }
764        public String toCode() {
765          switch (this) {
766            case CREATE: return "create";
767            case COPY: return "copy";
768            case TRUNCATE: return "truncate";
769            case ESCAPE: return "escape";
770            case CAST: return "cast";
771            case APPEND: return "append";
772            case TRANSLATE: return "translate";
773            case REFERENCE: return "reference";
774            case DATEOP: return "dateOp";
775            case UUID: return "uuid";
776            case POINTER: return "pointer";
777            case EVALUATE: return "evaluate";
778            case CC: return "cc";
779            case C: return "c";
780            case QTY: return "qty";
781            case ID: return "id";
782            case CP: return "cp";
783            case NULL: return null;
784            default: return "?";
785          }
786        }
787        public String getSystem() {
788          switch (this) {
789            case CREATE: return "http://hl7.org/fhir/map-transform";
790            case COPY: return "http://hl7.org/fhir/map-transform";
791            case TRUNCATE: return "http://hl7.org/fhir/map-transform";
792            case ESCAPE: return "http://hl7.org/fhir/map-transform";
793            case CAST: return "http://hl7.org/fhir/map-transform";
794            case APPEND: return "http://hl7.org/fhir/map-transform";
795            case TRANSLATE: return "http://hl7.org/fhir/map-transform";
796            case REFERENCE: return "http://hl7.org/fhir/map-transform";
797            case DATEOP: return "http://hl7.org/fhir/map-transform";
798            case UUID: return "http://hl7.org/fhir/map-transform";
799            case POINTER: return "http://hl7.org/fhir/map-transform";
800            case EVALUATE: return "http://hl7.org/fhir/map-transform";
801            case CC: return "http://hl7.org/fhir/map-transform";
802            case C: return "http://hl7.org/fhir/map-transform";
803            case QTY: return "http://hl7.org/fhir/map-transform";
804            case ID: return "http://hl7.org/fhir/map-transform";
805            case CP: return "http://hl7.org/fhir/map-transform";
806            case NULL: return null;
807            default: return "?";
808          }
809        }
810        public String getDefinition() {
811          switch (this) {
812            case CREATE: return "create(type : string) - type is passed through to the application on the standard API, and must be known by it.";
813            case COPY: return "copy(source).";
814            case TRUNCATE: return "truncate(source, length) - source must be stringy type.";
815            case ESCAPE: return "escape(source, fmt1, fmt2) - change source from one kind of escaping to another (plain, java, xml, json). note that this is for when the string itself is escaped.";
816            case CAST: return "cast(source, type?) - case source from one type to another. target type can be left as implicit if there is one and only one target type known.";
817            case APPEND: return "append(source...) - source is element or string.";
818            case TRANSLATE: return "translate(source, uri_of_map) - use the translate operation.";
819            case REFERENCE: return "reference(source : object) - return a string that references the provided tree properly.";
820            case DATEOP: return "Perform a date operation. *Parameters to be documented*.";
821            case UUID: return "Generate a random UUID (in lowercase). No Parameters.";
822            case POINTER: return "Return the appropriate string to put in a reference that refers to the resource provided as a parameter.";
823            case EVALUATE: return "Execute the supplied FHIRPath expression and use the value returned by that.";
824            case CC: return "Create a CodeableConcept. Parameters = (text) or (system. Code[, display]).";
825            case C: return "Create a Coding. Parameters = (system. Code[, display]).";
826            case QTY: return "Create a quantity. Parameters = (text) or (value, unit, [system, code]) where text is the natural representation e.g. [comparator]value[space]unit.";
827            case ID: return "Create an identifier. Parameters = (system, value[, type]) where type is a code from the identifier type value set.";
828            case CP: return "Create a contact details. Parameters = (value) or (system, value). If no system is provided, the system should be inferred from the content of the value.";
829            case NULL: return null;
830            default: return "?";
831          }
832        }
833        public String getDisplay() {
834          switch (this) {
835            case CREATE: return "create";
836            case COPY: return "copy";
837            case TRUNCATE: return "truncate";
838            case ESCAPE: return "escape";
839            case CAST: return "cast";
840            case APPEND: return "append";
841            case TRANSLATE: return "translate";
842            case REFERENCE: return "reference";
843            case DATEOP: return "dateOp";
844            case UUID: return "uuid";
845            case POINTER: return "pointer";
846            case EVALUATE: return "evaluate";
847            case CC: return "cc";
848            case C: return "c";
849            case QTY: return "qty";
850            case ID: return "id";
851            case CP: return "cp";
852            case NULL: return null;
853            default: return "?";
854          }
855        }
856    }
857
858  public static class StructureMapTransformEnumFactory implements EnumFactory<StructureMapTransform> {
859    public StructureMapTransform fromCode(String codeString) throws IllegalArgumentException {
860      if (codeString == null || "".equals(codeString))
861            if (codeString == null || "".equals(codeString))
862                return null;
863        if ("create".equals(codeString))
864          return StructureMapTransform.CREATE;
865        if ("copy".equals(codeString))
866          return StructureMapTransform.COPY;
867        if ("truncate".equals(codeString))
868          return StructureMapTransform.TRUNCATE;
869        if ("escape".equals(codeString))
870          return StructureMapTransform.ESCAPE;
871        if ("cast".equals(codeString))
872          return StructureMapTransform.CAST;
873        if ("append".equals(codeString))
874          return StructureMapTransform.APPEND;
875        if ("translate".equals(codeString))
876          return StructureMapTransform.TRANSLATE;
877        if ("reference".equals(codeString))
878          return StructureMapTransform.REFERENCE;
879        if ("dateOp".equals(codeString))
880          return StructureMapTransform.DATEOP;
881        if ("uuid".equals(codeString))
882          return StructureMapTransform.UUID;
883        if ("pointer".equals(codeString))
884          return StructureMapTransform.POINTER;
885        if ("evaluate".equals(codeString))
886          return StructureMapTransform.EVALUATE;
887        if ("cc".equals(codeString))
888          return StructureMapTransform.CC;
889        if ("c".equals(codeString))
890          return StructureMapTransform.C;
891        if ("qty".equals(codeString))
892          return StructureMapTransform.QTY;
893        if ("id".equals(codeString))
894          return StructureMapTransform.ID;
895        if ("cp".equals(codeString))
896          return StructureMapTransform.CP;
897        throw new IllegalArgumentException("Unknown StructureMapTransform code '"+codeString+"'");
898        }
899        public Enumeration<StructureMapTransform> fromType(Base code) throws FHIRException {
900          if (code == null)
901            return null;
902          if (code.isEmpty())
903            return new Enumeration<StructureMapTransform>(this);
904          String codeString = ((PrimitiveType) code).asStringValue();
905          if (codeString == null || "".equals(codeString))
906            return null;
907        if ("create".equals(codeString))
908          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.CREATE);
909        if ("copy".equals(codeString))
910          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.COPY);
911        if ("truncate".equals(codeString))
912          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.TRUNCATE);
913        if ("escape".equals(codeString))
914          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.ESCAPE);
915        if ("cast".equals(codeString))
916          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.CAST);
917        if ("append".equals(codeString))
918          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.APPEND);
919        if ("translate".equals(codeString))
920          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.TRANSLATE);
921        if ("reference".equals(codeString))
922          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.REFERENCE);
923        if ("dateOp".equals(codeString))
924          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.DATEOP);
925        if ("uuid".equals(codeString))
926          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.UUID);
927        if ("pointer".equals(codeString))
928          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.POINTER);
929        if ("evaluate".equals(codeString))
930          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.EVALUATE);
931        if ("cc".equals(codeString))
932          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.CC);
933        if ("c".equals(codeString))
934          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.C);
935        if ("qty".equals(codeString))
936          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.QTY);
937        if ("id".equals(codeString))
938          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.ID);
939        if ("cp".equals(codeString))
940          return new Enumeration<StructureMapTransform>(this, StructureMapTransform.CP);
941        throw new FHIRException("Unknown StructureMapTransform code '"+codeString+"'");
942        }
943    public String toCode(StructureMapTransform code) {
944      if (code == StructureMapTransform.CREATE)
945        return "create";
946      if (code == StructureMapTransform.COPY)
947        return "copy";
948      if (code == StructureMapTransform.TRUNCATE)
949        return "truncate";
950      if (code == StructureMapTransform.ESCAPE)
951        return "escape";
952      if (code == StructureMapTransform.CAST)
953        return "cast";
954      if (code == StructureMapTransform.APPEND)
955        return "append";
956      if (code == StructureMapTransform.TRANSLATE)
957        return "translate";
958      if (code == StructureMapTransform.REFERENCE)
959        return "reference";
960      if (code == StructureMapTransform.DATEOP)
961        return "dateOp";
962      if (code == StructureMapTransform.UUID)
963        return "uuid";
964      if (code == StructureMapTransform.POINTER)
965        return "pointer";
966      if (code == StructureMapTransform.EVALUATE)
967        return "evaluate";
968      if (code == StructureMapTransform.CC)
969        return "cc";
970      if (code == StructureMapTransform.C)
971        return "c";
972      if (code == StructureMapTransform.QTY)
973        return "qty";
974      if (code == StructureMapTransform.ID)
975        return "id";
976      if (code == StructureMapTransform.CP)
977        return "cp";
978      return "?";
979      }
980    public String toSystem(StructureMapTransform code) {
981      return code.getSystem();
982      }
983    }
984
985    @Block()
986    public static class StructureMapStructureComponent extends BackboneElement implements IBaseBackboneElement {
987        /**
988         * The canonical reference to the structure.
989         */
990        @Child(name = "url", type = {CanonicalType.class}, order=1, min=1, max=1, modifier=false, summary=true)
991        @Description(shortDefinition="Canonical reference to structure definition", formalDefinition="The canonical reference to the structure." )
992        protected CanonicalType url;
993
994        /**
995         * How the referenced structure is used in this mapping.
996         */
997        @Child(name = "mode", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=true)
998        @Description(shortDefinition="source | queried | target | produced", formalDefinition="How the referenced structure is used in this mapping." )
999        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/map-model-mode")
1000        protected Enumeration<StructureMapModelMode> mode;
1001
1002        /**
1003         * The name used for this type in the map.
1004         */
1005        @Child(name = "alias", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true)
1006        @Description(shortDefinition="Name for type in this map", formalDefinition="The name used for this type in the map." )
1007        protected StringType alias;
1008
1009        /**
1010         * Documentation that describes how the structure is used in the mapping.
1011         */
1012        @Child(name = "documentation", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
1013        @Description(shortDefinition="Documentation on use of structure", formalDefinition="Documentation that describes how the structure is used in the mapping." )
1014        protected StringType documentation;
1015
1016        private static final long serialVersionUID = 364750586L;
1017
1018    /**
1019     * Constructor
1020     */
1021      public StructureMapStructureComponent() {
1022        super();
1023      }
1024
1025    /**
1026     * Constructor
1027     */
1028      public StructureMapStructureComponent(String url, StructureMapModelMode mode) {
1029        super();
1030        this.setUrl(url);
1031        this.setMode(mode);
1032      }
1033
1034        /**
1035         * @return {@link #url} (The canonical reference to the structure.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1036         */
1037        public CanonicalType getUrlElement() { 
1038          if (this.url == null)
1039            if (Configuration.errorOnAutoCreate())
1040              throw new Error("Attempt to auto-create StructureMapStructureComponent.url");
1041            else if (Configuration.doAutoCreate())
1042              this.url = new CanonicalType(); // bb
1043          return this.url;
1044        }
1045
1046        public boolean hasUrlElement() { 
1047          return this.url != null && !this.url.isEmpty();
1048        }
1049
1050        public boolean hasUrl() { 
1051          return this.url != null && !this.url.isEmpty();
1052        }
1053
1054        /**
1055         * @param value {@link #url} (The canonical reference to the structure.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1056         */
1057        public StructureMapStructureComponent setUrlElement(CanonicalType value) { 
1058          this.url = value;
1059          return this;
1060        }
1061
1062        /**
1063         * @return The canonical reference to the structure.
1064         */
1065        public String getUrl() { 
1066          return this.url == null ? null : this.url.getValue();
1067        }
1068
1069        /**
1070         * @param value The canonical reference to the structure.
1071         */
1072        public StructureMapStructureComponent setUrl(String value) { 
1073            if (this.url == null)
1074              this.url = new CanonicalType();
1075            this.url.setValue(value);
1076          return this;
1077        }
1078
1079        /**
1080         * @return {@link #mode} (How the referenced structure is used in this mapping.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
1081         */
1082        public Enumeration<StructureMapModelMode> getModeElement() { 
1083          if (this.mode == null)
1084            if (Configuration.errorOnAutoCreate())
1085              throw new Error("Attempt to auto-create StructureMapStructureComponent.mode");
1086            else if (Configuration.doAutoCreate())
1087              this.mode = new Enumeration<StructureMapModelMode>(new StructureMapModelModeEnumFactory()); // bb
1088          return this.mode;
1089        }
1090
1091        public boolean hasModeElement() { 
1092          return this.mode != null && !this.mode.isEmpty();
1093        }
1094
1095        public boolean hasMode() { 
1096          return this.mode != null && !this.mode.isEmpty();
1097        }
1098
1099        /**
1100         * @param value {@link #mode} (How the referenced structure is used in this mapping.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
1101         */
1102        public StructureMapStructureComponent setModeElement(Enumeration<StructureMapModelMode> value) { 
1103          this.mode = value;
1104          return this;
1105        }
1106
1107        /**
1108         * @return How the referenced structure is used in this mapping.
1109         */
1110        public StructureMapModelMode getMode() { 
1111          return this.mode == null ? null : this.mode.getValue();
1112        }
1113
1114        /**
1115         * @param value How the referenced structure is used in this mapping.
1116         */
1117        public StructureMapStructureComponent setMode(StructureMapModelMode value) { 
1118            if (this.mode == null)
1119              this.mode = new Enumeration<StructureMapModelMode>(new StructureMapModelModeEnumFactory());
1120            this.mode.setValue(value);
1121          return this;
1122        }
1123
1124        /**
1125         * @return {@link #alias} (The name used for this type in the map.). This is the underlying object with id, value and extensions. The accessor "getAlias" gives direct access to the value
1126         */
1127        public StringType getAliasElement() { 
1128          if (this.alias == null)
1129            if (Configuration.errorOnAutoCreate())
1130              throw new Error("Attempt to auto-create StructureMapStructureComponent.alias");
1131            else if (Configuration.doAutoCreate())
1132              this.alias = new StringType(); // bb
1133          return this.alias;
1134        }
1135
1136        public boolean hasAliasElement() { 
1137          return this.alias != null && !this.alias.isEmpty();
1138        }
1139
1140        public boolean hasAlias() { 
1141          return this.alias != null && !this.alias.isEmpty();
1142        }
1143
1144        /**
1145         * @param value {@link #alias} (The name used for this type in the map.). This is the underlying object with id, value and extensions. The accessor "getAlias" gives direct access to the value
1146         */
1147        public StructureMapStructureComponent setAliasElement(StringType value) { 
1148          this.alias = value;
1149          return this;
1150        }
1151
1152        /**
1153         * @return The name used for this type in the map.
1154         */
1155        public String getAlias() { 
1156          return this.alias == null ? null : this.alias.getValue();
1157        }
1158
1159        /**
1160         * @param value The name used for this type in the map.
1161         */
1162        public StructureMapStructureComponent setAlias(String value) { 
1163          if (Utilities.noString(value))
1164            this.alias = null;
1165          else {
1166            if (this.alias == null)
1167              this.alias = new StringType();
1168            this.alias.setValue(value);
1169          }
1170          return this;
1171        }
1172
1173        /**
1174         * @return {@link #documentation} (Documentation that describes how the structure is used in the mapping.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
1175         */
1176        public StringType getDocumentationElement() { 
1177          if (this.documentation == null)
1178            if (Configuration.errorOnAutoCreate())
1179              throw new Error("Attempt to auto-create StructureMapStructureComponent.documentation");
1180            else if (Configuration.doAutoCreate())
1181              this.documentation = new StringType(); // bb
1182          return this.documentation;
1183        }
1184
1185        public boolean hasDocumentationElement() { 
1186          return this.documentation != null && !this.documentation.isEmpty();
1187        }
1188
1189        public boolean hasDocumentation() { 
1190          return this.documentation != null && !this.documentation.isEmpty();
1191        }
1192
1193        /**
1194         * @param value {@link #documentation} (Documentation that describes how the structure is used in the mapping.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
1195         */
1196        public StructureMapStructureComponent setDocumentationElement(StringType value) { 
1197          this.documentation = value;
1198          return this;
1199        }
1200
1201        /**
1202         * @return Documentation that describes how the structure is used in the mapping.
1203         */
1204        public String getDocumentation() { 
1205          return this.documentation == null ? null : this.documentation.getValue();
1206        }
1207
1208        /**
1209         * @param value Documentation that describes how the structure is used in the mapping.
1210         */
1211        public StructureMapStructureComponent setDocumentation(String value) { 
1212          if (Utilities.noString(value))
1213            this.documentation = null;
1214          else {
1215            if (this.documentation == null)
1216              this.documentation = new StringType();
1217            this.documentation.setValue(value);
1218          }
1219          return this;
1220        }
1221
1222        protected void listChildren(List<Property> children) {
1223          super.listChildren(children);
1224          children.add(new Property("url", "canonical(StructureDefinition)", "The canonical reference to the structure.", 0, 1, url));
1225          children.add(new Property("mode", "code", "How the referenced structure is used in this mapping.", 0, 1, mode));
1226          children.add(new Property("alias", "string", "The name used for this type in the map.", 0, 1, alias));
1227          children.add(new Property("documentation", "string", "Documentation that describes how the structure is used in the mapping.", 0, 1, documentation));
1228        }
1229
1230        @Override
1231        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1232          switch (_hash) {
1233          case 116079: /*url*/  return new Property("url", "canonical(StructureDefinition)", "The canonical reference to the structure.", 0, 1, url);
1234          case 3357091: /*mode*/  return new Property("mode", "code", "How the referenced structure is used in this mapping.", 0, 1, mode);
1235          case 92902992: /*alias*/  return new Property("alias", "string", "The name used for this type in the map.", 0, 1, alias);
1236          case 1587405498: /*documentation*/  return new Property("documentation", "string", "Documentation that describes how the structure is used in the mapping.", 0, 1, documentation);
1237          default: return super.getNamedProperty(_hash, _name, _checkValid);
1238          }
1239
1240        }
1241
1242      @Override
1243      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1244        switch (hash) {
1245        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // CanonicalType
1246        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<StructureMapModelMode>
1247        case 92902992: /*alias*/ return this.alias == null ? new Base[0] : new Base[] {this.alias}; // StringType
1248        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // StringType
1249        default: return super.getProperty(hash, name, checkValid);
1250        }
1251
1252      }
1253
1254      @Override
1255      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1256        switch (hash) {
1257        case 116079: // url
1258          this.url = TypeConvertor.castToCanonical(value); // CanonicalType
1259          return value;
1260        case 3357091: // mode
1261          value = new StructureMapModelModeEnumFactory().fromType(TypeConvertor.castToCode(value));
1262          this.mode = (Enumeration) value; // Enumeration<StructureMapModelMode>
1263          return value;
1264        case 92902992: // alias
1265          this.alias = TypeConvertor.castToString(value); // StringType
1266          return value;
1267        case 1587405498: // documentation
1268          this.documentation = TypeConvertor.castToString(value); // StringType
1269          return value;
1270        default: return super.setProperty(hash, name, value);
1271        }
1272
1273      }
1274
1275      @Override
1276      public Base setProperty(String name, Base value) throws FHIRException {
1277        if (name.equals("url")) {
1278          this.url = TypeConvertor.castToCanonical(value); // CanonicalType
1279        } else if (name.equals("mode")) {
1280          value = new StructureMapModelModeEnumFactory().fromType(TypeConvertor.castToCode(value));
1281          this.mode = (Enumeration) value; // Enumeration<StructureMapModelMode>
1282        } else if (name.equals("alias")) {
1283          this.alias = TypeConvertor.castToString(value); // StringType
1284        } else if (name.equals("documentation")) {
1285          this.documentation = TypeConvertor.castToString(value); // StringType
1286        } else
1287          return super.setProperty(name, value);
1288        return value;
1289      }
1290
1291      @Override
1292      public Base makeProperty(int hash, String name) throws FHIRException {
1293        switch (hash) {
1294        case 116079:  return getUrlElement();
1295        case 3357091:  return getModeElement();
1296        case 92902992:  return getAliasElement();
1297        case 1587405498:  return getDocumentationElement();
1298        default: return super.makeProperty(hash, name);
1299        }
1300
1301      }
1302
1303      @Override
1304      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1305        switch (hash) {
1306        case 116079: /*url*/ return new String[] {"canonical"};
1307        case 3357091: /*mode*/ return new String[] {"code"};
1308        case 92902992: /*alias*/ return new String[] {"string"};
1309        case 1587405498: /*documentation*/ return new String[] {"string"};
1310        default: return super.getTypesForProperty(hash, name);
1311        }
1312
1313      }
1314
1315      @Override
1316      public Base addChild(String name) throws FHIRException {
1317        if (name.equals("url")) {
1318          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.structure.url");
1319        }
1320        else if (name.equals("mode")) {
1321          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.structure.mode");
1322        }
1323        else if (name.equals("alias")) {
1324          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.structure.alias");
1325        }
1326        else if (name.equals("documentation")) {
1327          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.structure.documentation");
1328        }
1329        else
1330          return super.addChild(name);
1331      }
1332
1333      public StructureMapStructureComponent copy() {
1334        StructureMapStructureComponent dst = new StructureMapStructureComponent();
1335        copyValues(dst);
1336        return dst;
1337      }
1338
1339      public void copyValues(StructureMapStructureComponent dst) {
1340        super.copyValues(dst);
1341        dst.url = url == null ? null : url.copy();
1342        dst.mode = mode == null ? null : mode.copy();
1343        dst.alias = alias == null ? null : alias.copy();
1344        dst.documentation = documentation == null ? null : documentation.copy();
1345      }
1346
1347      @Override
1348      public boolean equalsDeep(Base other_) {
1349        if (!super.equalsDeep(other_))
1350          return false;
1351        if (!(other_ instanceof StructureMapStructureComponent))
1352          return false;
1353        StructureMapStructureComponent o = (StructureMapStructureComponent) other_;
1354        return compareDeep(url, o.url, true) && compareDeep(mode, o.mode, true) && compareDeep(alias, o.alias, true)
1355           && compareDeep(documentation, o.documentation, true);
1356      }
1357
1358      @Override
1359      public boolean equalsShallow(Base other_) {
1360        if (!super.equalsShallow(other_))
1361          return false;
1362        if (!(other_ instanceof StructureMapStructureComponent))
1363          return false;
1364        StructureMapStructureComponent o = (StructureMapStructureComponent) other_;
1365        return compareValues(url, o.url, true) && compareValues(mode, o.mode, true) && compareValues(alias, o.alias, true)
1366           && compareValues(documentation, o.documentation, true);
1367      }
1368
1369      public boolean isEmpty() {
1370        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, mode, alias, documentation
1371          );
1372      }
1373
1374  public String fhirType() {
1375    return "StructureMap.structure";
1376
1377  }
1378
1379  }
1380
1381    @Block()
1382    public static class StructureMapGroupComponent extends BackboneElement implements IBaseBackboneElement {
1383        /**
1384         * A unique name for the group for the convenience of human readers.
1385         */
1386        @Child(name = "name", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1387        @Description(shortDefinition="Human-readable label", formalDefinition="A unique name for the group for the convenience of human readers." )
1388        protected IdType name;
1389
1390        /**
1391         * Another group that this group adds rules to.
1392         */
1393        @Child(name = "extends", type = {IdType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1394        @Description(shortDefinition="Another group that this group adds rules to", formalDefinition="Another group that this group adds rules to." )
1395        protected IdType extends_;
1396
1397        /**
1398         * If this is the default rule set to apply for the source type or this combination of types.
1399         */
1400        @Child(name = "typeMode", type = {CodeType.class}, order=3, min=0, max=1, modifier=false, summary=true)
1401        @Description(shortDefinition="types | type-and-types", formalDefinition="If this is the default rule set to apply for the source type or this combination of types." )
1402        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/map-group-type-mode")
1403        protected Enumeration<StructureMapGroupTypeMode> typeMode;
1404
1405        /**
1406         * Additional supporting documentation that explains the purpose of the group and the types of mappings within it.
1407         */
1408        @Child(name = "documentation", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
1409        @Description(shortDefinition="Additional description/explanation for group", formalDefinition="Additional supporting documentation that explains the purpose of the group and the types of mappings within it." )
1410        protected StringType documentation;
1411
1412        /**
1413         * A name assigned to an instance of data. The instance must be provided when the mapping is invoked.
1414         */
1415        @Child(name = "input", type = {}, order=5, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1416        @Description(shortDefinition="Named instance provided when invoking the map", formalDefinition="A name assigned to an instance of data. The instance must be provided when the mapping is invoked." )
1417        protected List<StructureMapGroupInputComponent> input;
1418
1419        /**
1420         * Transform Rule from source to target.
1421         */
1422        @Child(name = "rule", type = {}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1423        @Description(shortDefinition="Transform Rule from source to target", formalDefinition="Transform Rule from source to target." )
1424        protected List<StructureMapGroupRuleComponent> rule;
1425
1426        private static final long serialVersionUID = -1474595081L;
1427
1428    /**
1429     * Constructor
1430     */
1431      public StructureMapGroupComponent() {
1432        super();
1433      }
1434
1435    /**
1436     * Constructor
1437     */
1438      public StructureMapGroupComponent(String name, StructureMapGroupInputComponent input) {
1439        super();
1440        this.setName(name);
1441        this.addInput(input);
1442      }
1443
1444        /**
1445         * @return {@link #name} (A unique name for the group for the convenience of human readers.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1446         */
1447        public IdType getNameElement() { 
1448          if (this.name == null)
1449            if (Configuration.errorOnAutoCreate())
1450              throw new Error("Attempt to auto-create StructureMapGroupComponent.name");
1451            else if (Configuration.doAutoCreate())
1452              this.name = new IdType(); // bb
1453          return this.name;
1454        }
1455
1456        public boolean hasNameElement() { 
1457          return this.name != null && !this.name.isEmpty();
1458        }
1459
1460        public boolean hasName() { 
1461          return this.name != null && !this.name.isEmpty();
1462        }
1463
1464        /**
1465         * @param value {@link #name} (A unique name for the group for the convenience of human readers.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1466         */
1467        public StructureMapGroupComponent setNameElement(IdType value) { 
1468          this.name = value;
1469          return this;
1470        }
1471
1472        /**
1473         * @return A unique name for the group for the convenience of human readers.
1474         */
1475        public String getName() { 
1476          return this.name == null ? null : this.name.getValue();
1477        }
1478
1479        /**
1480         * @param value A unique name for the group for the convenience of human readers.
1481         */
1482        public StructureMapGroupComponent setName(String value) { 
1483            if (this.name == null)
1484              this.name = new IdType();
1485            this.name.setValue(value);
1486          return this;
1487        }
1488
1489        /**
1490         * @return {@link #extends_} (Another group that this group adds rules to.). This is the underlying object with id, value and extensions. The accessor "getExtends" gives direct access to the value
1491         */
1492        public IdType getExtendsElement() { 
1493          if (this.extends_ == null)
1494            if (Configuration.errorOnAutoCreate())
1495              throw new Error("Attempt to auto-create StructureMapGroupComponent.extends_");
1496            else if (Configuration.doAutoCreate())
1497              this.extends_ = new IdType(); // bb
1498          return this.extends_;
1499        }
1500
1501        public boolean hasExtendsElement() { 
1502          return this.extends_ != null && !this.extends_.isEmpty();
1503        }
1504
1505        public boolean hasExtends() { 
1506          return this.extends_ != null && !this.extends_.isEmpty();
1507        }
1508
1509        /**
1510         * @param value {@link #extends_} (Another group that this group adds rules to.). This is the underlying object with id, value and extensions. The accessor "getExtends" gives direct access to the value
1511         */
1512        public StructureMapGroupComponent setExtendsElement(IdType value) { 
1513          this.extends_ = value;
1514          return this;
1515        }
1516
1517        /**
1518         * @return Another group that this group adds rules to.
1519         */
1520        public String getExtends() { 
1521          return this.extends_ == null ? null : this.extends_.getValue();
1522        }
1523
1524        /**
1525         * @param value Another group that this group adds rules to.
1526         */
1527        public StructureMapGroupComponent setExtends(String value) { 
1528          if (Utilities.noString(value))
1529            this.extends_ = null;
1530          else {
1531            if (this.extends_ == null)
1532              this.extends_ = new IdType();
1533            this.extends_.setValue(value);
1534          }
1535          return this;
1536        }
1537
1538        /**
1539         * @return {@link #typeMode} (If this is the default rule set to apply for the source type or this combination of types.). This is the underlying object with id, value and extensions. The accessor "getTypeMode" gives direct access to the value
1540         */
1541        public Enumeration<StructureMapGroupTypeMode> getTypeModeElement() { 
1542          if (this.typeMode == null)
1543            if (Configuration.errorOnAutoCreate())
1544              throw new Error("Attempt to auto-create StructureMapGroupComponent.typeMode");
1545            else if (Configuration.doAutoCreate())
1546              this.typeMode = new Enumeration<StructureMapGroupTypeMode>(new StructureMapGroupTypeModeEnumFactory()); // bb
1547          return this.typeMode;
1548        }
1549
1550        public boolean hasTypeModeElement() { 
1551          return this.typeMode != null && !this.typeMode.isEmpty();
1552        }
1553
1554        public boolean hasTypeMode() { 
1555          return this.typeMode != null && !this.typeMode.isEmpty();
1556        }
1557
1558        /**
1559         * @param value {@link #typeMode} (If this is the default rule set to apply for the source type or this combination of types.). This is the underlying object with id, value and extensions. The accessor "getTypeMode" gives direct access to the value
1560         */
1561        public StructureMapGroupComponent setTypeModeElement(Enumeration<StructureMapGroupTypeMode> value) { 
1562          this.typeMode = value;
1563          return this;
1564        }
1565
1566        /**
1567         * @return If this is the default rule set to apply for the source type or this combination of types.
1568         */
1569        public StructureMapGroupTypeMode getTypeMode() { 
1570          return this.typeMode == null ? null : this.typeMode.getValue();
1571        }
1572
1573        /**
1574         * @param value If this is the default rule set to apply for the source type or this combination of types.
1575         */
1576        public StructureMapGroupComponent setTypeMode(StructureMapGroupTypeMode value) { 
1577          if (value == null)
1578            this.typeMode = null;
1579          else {
1580            if (this.typeMode == null)
1581              this.typeMode = new Enumeration<StructureMapGroupTypeMode>(new StructureMapGroupTypeModeEnumFactory());
1582            this.typeMode.setValue(value);
1583          }
1584          return this;
1585        }
1586
1587        /**
1588         * @return {@link #documentation} (Additional supporting documentation that explains the purpose of the group and the types of mappings within it.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
1589         */
1590        public StringType getDocumentationElement() { 
1591          if (this.documentation == null)
1592            if (Configuration.errorOnAutoCreate())
1593              throw new Error("Attempt to auto-create StructureMapGroupComponent.documentation");
1594            else if (Configuration.doAutoCreate())
1595              this.documentation = new StringType(); // bb
1596          return this.documentation;
1597        }
1598
1599        public boolean hasDocumentationElement() { 
1600          return this.documentation != null && !this.documentation.isEmpty();
1601        }
1602
1603        public boolean hasDocumentation() { 
1604          return this.documentation != null && !this.documentation.isEmpty();
1605        }
1606
1607        /**
1608         * @param value {@link #documentation} (Additional supporting documentation that explains the purpose of the group and the types of mappings within it.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
1609         */
1610        public StructureMapGroupComponent setDocumentationElement(StringType value) { 
1611          this.documentation = value;
1612          return this;
1613        }
1614
1615        /**
1616         * @return Additional supporting documentation that explains the purpose of the group and the types of mappings within it.
1617         */
1618        public String getDocumentation() { 
1619          return this.documentation == null ? null : this.documentation.getValue();
1620        }
1621
1622        /**
1623         * @param value Additional supporting documentation that explains the purpose of the group and the types of mappings within it.
1624         */
1625        public StructureMapGroupComponent setDocumentation(String value) { 
1626          if (Utilities.noString(value))
1627            this.documentation = null;
1628          else {
1629            if (this.documentation == null)
1630              this.documentation = new StringType();
1631            this.documentation.setValue(value);
1632          }
1633          return this;
1634        }
1635
1636        /**
1637         * @return {@link #input} (A name assigned to an instance of data. The instance must be provided when the mapping is invoked.)
1638         */
1639        public List<StructureMapGroupInputComponent> getInput() { 
1640          if (this.input == null)
1641            this.input = new ArrayList<StructureMapGroupInputComponent>();
1642          return this.input;
1643        }
1644
1645        /**
1646         * @return Returns a reference to <code>this</code> for easy method chaining
1647         */
1648        public StructureMapGroupComponent setInput(List<StructureMapGroupInputComponent> theInput) { 
1649          this.input = theInput;
1650          return this;
1651        }
1652
1653        public boolean hasInput() { 
1654          if (this.input == null)
1655            return false;
1656          for (StructureMapGroupInputComponent item : this.input)
1657            if (!item.isEmpty())
1658              return true;
1659          return false;
1660        }
1661
1662        public StructureMapGroupInputComponent addInput() { //3
1663          StructureMapGroupInputComponent t = new StructureMapGroupInputComponent();
1664          if (this.input == null)
1665            this.input = new ArrayList<StructureMapGroupInputComponent>();
1666          this.input.add(t);
1667          return t;
1668        }
1669
1670        public StructureMapGroupComponent addInput(StructureMapGroupInputComponent t) { //3
1671          if (t == null)
1672            return this;
1673          if (this.input == null)
1674            this.input = new ArrayList<StructureMapGroupInputComponent>();
1675          this.input.add(t);
1676          return this;
1677        }
1678
1679        /**
1680         * @return The first repetition of repeating field {@link #input}, creating it if it does not already exist {3}
1681         */
1682        public StructureMapGroupInputComponent getInputFirstRep() { 
1683          if (getInput().isEmpty()) {
1684            addInput();
1685          }
1686          return getInput().get(0);
1687        }
1688
1689        /**
1690         * @return {@link #rule} (Transform Rule from source to target.)
1691         */
1692        public List<StructureMapGroupRuleComponent> getRule() { 
1693          if (this.rule == null)
1694            this.rule = new ArrayList<StructureMapGroupRuleComponent>();
1695          return this.rule;
1696        }
1697
1698        /**
1699         * @return Returns a reference to <code>this</code> for easy method chaining
1700         */
1701        public StructureMapGroupComponent setRule(List<StructureMapGroupRuleComponent> theRule) { 
1702          this.rule = theRule;
1703          return this;
1704        }
1705
1706        public boolean hasRule() { 
1707          if (this.rule == null)
1708            return false;
1709          for (StructureMapGroupRuleComponent item : this.rule)
1710            if (!item.isEmpty())
1711              return true;
1712          return false;
1713        }
1714
1715        public StructureMapGroupRuleComponent addRule() { //3
1716          StructureMapGroupRuleComponent t = new StructureMapGroupRuleComponent();
1717          if (this.rule == null)
1718            this.rule = new ArrayList<StructureMapGroupRuleComponent>();
1719          this.rule.add(t);
1720          return t;
1721        }
1722
1723        public StructureMapGroupComponent addRule(StructureMapGroupRuleComponent t) { //3
1724          if (t == null)
1725            return this;
1726          if (this.rule == null)
1727            this.rule = new ArrayList<StructureMapGroupRuleComponent>();
1728          this.rule.add(t);
1729          return this;
1730        }
1731
1732        /**
1733         * @return The first repetition of repeating field {@link #rule}, creating it if it does not already exist {3}
1734         */
1735        public StructureMapGroupRuleComponent getRuleFirstRep() { 
1736          if (getRule().isEmpty()) {
1737            addRule();
1738          }
1739          return getRule().get(0);
1740        }
1741
1742        protected void listChildren(List<Property> children) {
1743          super.listChildren(children);
1744          children.add(new Property("name", "id", "A unique name for the group for the convenience of human readers.", 0, 1, name));
1745          children.add(new Property("extends", "id", "Another group that this group adds rules to.", 0, 1, extends_));
1746          children.add(new Property("typeMode", "code", "If this is the default rule set to apply for the source type or this combination of types.", 0, 1, typeMode));
1747          children.add(new Property("documentation", "string", "Additional supporting documentation that explains the purpose of the group and the types of mappings within it.", 0, 1, documentation));
1748          children.add(new Property("input", "", "A name assigned to an instance of data. The instance must be provided when the mapping is invoked.", 0, java.lang.Integer.MAX_VALUE, input));
1749          children.add(new Property("rule", "", "Transform Rule from source to target.", 0, java.lang.Integer.MAX_VALUE, rule));
1750        }
1751
1752        @Override
1753        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1754          switch (_hash) {
1755          case 3373707: /*name*/  return new Property("name", "id", "A unique name for the group for the convenience of human readers.", 0, 1, name);
1756          case -1305664359: /*extends*/  return new Property("extends", "id", "Another group that this group adds rules to.", 0, 1, extends_);
1757          case -676524035: /*typeMode*/  return new Property("typeMode", "code", "If this is the default rule set to apply for the source type or this combination of types.", 0, 1, typeMode);
1758          case 1587405498: /*documentation*/  return new Property("documentation", "string", "Additional supporting documentation that explains the purpose of the group and the types of mappings within it.", 0, 1, documentation);
1759          case 100358090: /*input*/  return new Property("input", "", "A name assigned to an instance of data. The instance must be provided when the mapping is invoked.", 0, java.lang.Integer.MAX_VALUE, input);
1760          case 3512060: /*rule*/  return new Property("rule", "", "Transform Rule from source to target.", 0, java.lang.Integer.MAX_VALUE, rule);
1761          default: return super.getNamedProperty(_hash, _name, _checkValid);
1762          }
1763
1764        }
1765
1766      @Override
1767      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1768        switch (hash) {
1769        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // IdType
1770        case -1305664359: /*extends*/ return this.extends_ == null ? new Base[0] : new Base[] {this.extends_}; // IdType
1771        case -676524035: /*typeMode*/ return this.typeMode == null ? new Base[0] : new Base[] {this.typeMode}; // Enumeration<StructureMapGroupTypeMode>
1772        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // StringType
1773        case 100358090: /*input*/ return this.input == null ? new Base[0] : this.input.toArray(new Base[this.input.size()]); // StructureMapGroupInputComponent
1774        case 3512060: /*rule*/ return this.rule == null ? new Base[0] : this.rule.toArray(new Base[this.rule.size()]); // StructureMapGroupRuleComponent
1775        default: return super.getProperty(hash, name, checkValid);
1776        }
1777
1778      }
1779
1780      @Override
1781      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1782        switch (hash) {
1783        case 3373707: // name
1784          this.name = TypeConvertor.castToId(value); // IdType
1785          return value;
1786        case -1305664359: // extends
1787          this.extends_ = TypeConvertor.castToId(value); // IdType
1788          return value;
1789        case -676524035: // typeMode
1790          value = new StructureMapGroupTypeModeEnumFactory().fromType(TypeConvertor.castToCode(value));
1791          this.typeMode = (Enumeration) value; // Enumeration<StructureMapGroupTypeMode>
1792          return value;
1793        case 1587405498: // documentation
1794          this.documentation = TypeConvertor.castToString(value); // StringType
1795          return value;
1796        case 100358090: // input
1797          this.getInput().add((StructureMapGroupInputComponent) value); // StructureMapGroupInputComponent
1798          return value;
1799        case 3512060: // rule
1800          this.getRule().add((StructureMapGroupRuleComponent) value); // StructureMapGroupRuleComponent
1801          return value;
1802        default: return super.setProperty(hash, name, value);
1803        }
1804
1805      }
1806
1807      @Override
1808      public Base setProperty(String name, Base value) throws FHIRException {
1809        if (name.equals("name")) {
1810          this.name = TypeConvertor.castToId(value); // IdType
1811        } else if (name.equals("extends")) {
1812          this.extends_ = TypeConvertor.castToId(value); // IdType
1813        } else if (name.equals("typeMode")) {
1814          value = new StructureMapGroupTypeModeEnumFactory().fromType(TypeConvertor.castToCode(value));
1815          this.typeMode = (Enumeration) value; // Enumeration<StructureMapGroupTypeMode>
1816        } else if (name.equals("documentation")) {
1817          this.documentation = TypeConvertor.castToString(value); // StringType
1818        } else if (name.equals("input")) {
1819          this.getInput().add((StructureMapGroupInputComponent) value);
1820        } else if (name.equals("rule")) {
1821          this.getRule().add((StructureMapGroupRuleComponent) value);
1822        } else
1823          return super.setProperty(name, value);
1824        return value;
1825      }
1826
1827      @Override
1828      public Base makeProperty(int hash, String name) throws FHIRException {
1829        switch (hash) {
1830        case 3373707:  return getNameElement();
1831        case -1305664359:  return getExtendsElement();
1832        case -676524035:  return getTypeModeElement();
1833        case 1587405498:  return getDocumentationElement();
1834        case 100358090:  return addInput(); 
1835        case 3512060:  return addRule(); 
1836        default: return super.makeProperty(hash, name);
1837        }
1838
1839      }
1840
1841      @Override
1842      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1843        switch (hash) {
1844        case 3373707: /*name*/ return new String[] {"id"};
1845        case -1305664359: /*extends*/ return new String[] {"id"};
1846        case -676524035: /*typeMode*/ return new String[] {"code"};
1847        case 1587405498: /*documentation*/ return new String[] {"string"};
1848        case 100358090: /*input*/ return new String[] {};
1849        case 3512060: /*rule*/ return new String[] {};
1850        default: return super.getTypesForProperty(hash, name);
1851        }
1852
1853      }
1854
1855      @Override
1856      public Base addChild(String name) throws FHIRException {
1857        if (name.equals("name")) {
1858          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.name");
1859        }
1860        else if (name.equals("extends")) {
1861          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.extends");
1862        }
1863        else if (name.equals("typeMode")) {
1864          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.typeMode");
1865        }
1866        else if (name.equals("documentation")) {
1867          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.documentation");
1868        }
1869        else if (name.equals("input")) {
1870          return addInput();
1871        }
1872        else if (name.equals("rule")) {
1873          return addRule();
1874        }
1875        else
1876          return super.addChild(name);
1877      }
1878
1879      public StructureMapGroupComponent copy() {
1880        StructureMapGroupComponent dst = new StructureMapGroupComponent();
1881        copyValues(dst);
1882        return dst;
1883      }
1884
1885      public void copyValues(StructureMapGroupComponent dst) {
1886        super.copyValues(dst);
1887        dst.name = name == null ? null : name.copy();
1888        dst.extends_ = extends_ == null ? null : extends_.copy();
1889        dst.typeMode = typeMode == null ? null : typeMode.copy();
1890        dst.documentation = documentation == null ? null : documentation.copy();
1891        if (input != null) {
1892          dst.input = new ArrayList<StructureMapGroupInputComponent>();
1893          for (StructureMapGroupInputComponent i : input)
1894            dst.input.add(i.copy());
1895        };
1896        if (rule != null) {
1897          dst.rule = new ArrayList<StructureMapGroupRuleComponent>();
1898          for (StructureMapGroupRuleComponent i : rule)
1899            dst.rule.add(i.copy());
1900        };
1901      }
1902
1903      @Override
1904      public boolean equalsDeep(Base other_) {
1905        if (!super.equalsDeep(other_))
1906          return false;
1907        if (!(other_ instanceof StructureMapGroupComponent))
1908          return false;
1909        StructureMapGroupComponent o = (StructureMapGroupComponent) other_;
1910        return compareDeep(name, o.name, true) && compareDeep(extends_, o.extends_, true) && compareDeep(typeMode, o.typeMode, true)
1911           && compareDeep(documentation, o.documentation, true) && compareDeep(input, o.input, true) && compareDeep(rule, o.rule, true)
1912          ;
1913      }
1914
1915      @Override
1916      public boolean equalsShallow(Base other_) {
1917        if (!super.equalsShallow(other_))
1918          return false;
1919        if (!(other_ instanceof StructureMapGroupComponent))
1920          return false;
1921        StructureMapGroupComponent o = (StructureMapGroupComponent) other_;
1922        return compareValues(name, o.name, true) && compareValues(extends_, o.extends_, true) && compareValues(typeMode, o.typeMode, true)
1923           && compareValues(documentation, o.documentation, true);
1924      }
1925
1926      public boolean isEmpty() {
1927        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, extends_, typeMode
1928          , documentation, input, rule);
1929      }
1930
1931  public String fhirType() {
1932    return "StructureMap.group";
1933
1934  }
1935
1936// added from java-adornments.txt:
1937public String toString() {
1938    return StructureMapUtilities.groupToString(this);
1939  }
1940// end addition
1941  }
1942
1943    @Block()
1944    public static class StructureMapGroupInputComponent extends BackboneElement implements IBaseBackboneElement {
1945        /**
1946         * Name for this instance of data.
1947         */
1948        @Child(name = "name", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1949        @Description(shortDefinition="Name for this instance of data", formalDefinition="Name for this instance of data." )
1950        protected IdType name;
1951
1952        /**
1953         * Type for this instance of data.
1954         */
1955        @Child(name = "type", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1956        @Description(shortDefinition="Type for this instance of data", formalDefinition="Type for this instance of data." )
1957        protected StringType type;
1958
1959        /**
1960         * Mode for this instance of data.
1961         */
1962        @Child(name = "mode", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true)
1963        @Description(shortDefinition="source | target", formalDefinition="Mode for this instance of data." )
1964        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/map-input-mode")
1965        protected Enumeration<StructureMapInputMode> mode;
1966
1967        /**
1968         * Documentation for this instance of data.
1969         */
1970        @Child(name = "documentation", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
1971        @Description(shortDefinition="Documentation for this instance of data", formalDefinition="Documentation for this instance of data." )
1972        protected StringType documentation;
1973
1974        private static final long serialVersionUID = -25050724L;
1975
1976    /**
1977     * Constructor
1978     */
1979      public StructureMapGroupInputComponent() {
1980        super();
1981      }
1982
1983    /**
1984     * Constructor
1985     */
1986      public StructureMapGroupInputComponent(String name, StructureMapInputMode mode) {
1987        super();
1988        this.setName(name);
1989        this.setMode(mode);
1990      }
1991
1992        /**
1993         * @return {@link #name} (Name for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1994         */
1995        public IdType getNameElement() { 
1996          if (this.name == null)
1997            if (Configuration.errorOnAutoCreate())
1998              throw new Error("Attempt to auto-create StructureMapGroupInputComponent.name");
1999            else if (Configuration.doAutoCreate())
2000              this.name = new IdType(); // bb
2001          return this.name;
2002        }
2003
2004        public boolean hasNameElement() { 
2005          return this.name != null && !this.name.isEmpty();
2006        }
2007
2008        public boolean hasName() { 
2009          return this.name != null && !this.name.isEmpty();
2010        }
2011
2012        /**
2013         * @param value {@link #name} (Name for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
2014         */
2015        public StructureMapGroupInputComponent setNameElement(IdType value) { 
2016          this.name = value;
2017          return this;
2018        }
2019
2020        /**
2021         * @return Name for this instance of data.
2022         */
2023        public String getName() { 
2024          return this.name == null ? null : this.name.getValue();
2025        }
2026
2027        /**
2028         * @param value Name for this instance of data.
2029         */
2030        public StructureMapGroupInputComponent setName(String value) { 
2031            if (this.name == null)
2032              this.name = new IdType();
2033            this.name.setValue(value);
2034          return this;
2035        }
2036
2037        /**
2038         * @return {@link #type} (Type for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2039         */
2040        public StringType getTypeElement() { 
2041          if (this.type == null)
2042            if (Configuration.errorOnAutoCreate())
2043              throw new Error("Attempt to auto-create StructureMapGroupInputComponent.type");
2044            else if (Configuration.doAutoCreate())
2045              this.type = new StringType(); // bb
2046          return this.type;
2047        }
2048
2049        public boolean hasTypeElement() { 
2050          return this.type != null && !this.type.isEmpty();
2051        }
2052
2053        public boolean hasType() { 
2054          return this.type != null && !this.type.isEmpty();
2055        }
2056
2057        /**
2058         * @param value {@link #type} (Type for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2059         */
2060        public StructureMapGroupInputComponent setTypeElement(StringType value) { 
2061          this.type = value;
2062          return this;
2063        }
2064
2065        /**
2066         * @return Type for this instance of data.
2067         */
2068        public String getType() { 
2069          return this.type == null ? null : this.type.getValue();
2070        }
2071
2072        /**
2073         * @param value Type for this instance of data.
2074         */
2075        public StructureMapGroupInputComponent setType(String value) { 
2076          if (Utilities.noString(value))
2077            this.type = null;
2078          else {
2079            if (this.type == null)
2080              this.type = new StringType();
2081            this.type.setValue(value);
2082          }
2083          return this;
2084        }
2085
2086        /**
2087         * @return {@link #mode} (Mode for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
2088         */
2089        public Enumeration<StructureMapInputMode> getModeElement() { 
2090          if (this.mode == null)
2091            if (Configuration.errorOnAutoCreate())
2092              throw new Error("Attempt to auto-create StructureMapGroupInputComponent.mode");
2093            else if (Configuration.doAutoCreate())
2094              this.mode = new Enumeration<StructureMapInputMode>(new StructureMapInputModeEnumFactory()); // bb
2095          return this.mode;
2096        }
2097
2098        public boolean hasModeElement() { 
2099          return this.mode != null && !this.mode.isEmpty();
2100        }
2101
2102        public boolean hasMode() { 
2103          return this.mode != null && !this.mode.isEmpty();
2104        }
2105
2106        /**
2107         * @param value {@link #mode} (Mode for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
2108         */
2109        public StructureMapGroupInputComponent setModeElement(Enumeration<StructureMapInputMode> value) { 
2110          this.mode = value;
2111          return this;
2112        }
2113
2114        /**
2115         * @return Mode for this instance of data.
2116         */
2117        public StructureMapInputMode getMode() { 
2118          return this.mode == null ? null : this.mode.getValue();
2119        }
2120
2121        /**
2122         * @param value Mode for this instance of data.
2123         */
2124        public StructureMapGroupInputComponent setMode(StructureMapInputMode value) { 
2125            if (this.mode == null)
2126              this.mode = new Enumeration<StructureMapInputMode>(new StructureMapInputModeEnumFactory());
2127            this.mode.setValue(value);
2128          return this;
2129        }
2130
2131        /**
2132         * @return {@link #documentation} (Documentation for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
2133         */
2134        public StringType getDocumentationElement() { 
2135          if (this.documentation == null)
2136            if (Configuration.errorOnAutoCreate())
2137              throw new Error("Attempt to auto-create StructureMapGroupInputComponent.documentation");
2138            else if (Configuration.doAutoCreate())
2139              this.documentation = new StringType(); // bb
2140          return this.documentation;
2141        }
2142
2143        public boolean hasDocumentationElement() { 
2144          return this.documentation != null && !this.documentation.isEmpty();
2145        }
2146
2147        public boolean hasDocumentation() { 
2148          return this.documentation != null && !this.documentation.isEmpty();
2149        }
2150
2151        /**
2152         * @param value {@link #documentation} (Documentation for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
2153         */
2154        public StructureMapGroupInputComponent setDocumentationElement(StringType value) { 
2155          this.documentation = value;
2156          return this;
2157        }
2158
2159        /**
2160         * @return Documentation for this instance of data.
2161         */
2162        public String getDocumentation() { 
2163          return this.documentation == null ? null : this.documentation.getValue();
2164        }
2165
2166        /**
2167         * @param value Documentation for this instance of data.
2168         */
2169        public StructureMapGroupInputComponent setDocumentation(String value) { 
2170          if (Utilities.noString(value))
2171            this.documentation = null;
2172          else {
2173            if (this.documentation == null)
2174              this.documentation = new StringType();
2175            this.documentation.setValue(value);
2176          }
2177          return this;
2178        }
2179
2180        protected void listChildren(List<Property> children) {
2181          super.listChildren(children);
2182          children.add(new Property("name", "id", "Name for this instance of data.", 0, 1, name));
2183          children.add(new Property("type", "string", "Type for this instance of data.", 0, 1, type));
2184          children.add(new Property("mode", "code", "Mode for this instance of data.", 0, 1, mode));
2185          children.add(new Property("documentation", "string", "Documentation for this instance of data.", 0, 1, documentation));
2186        }
2187
2188        @Override
2189        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2190          switch (_hash) {
2191          case 3373707: /*name*/  return new Property("name", "id", "Name for this instance of data.", 0, 1, name);
2192          case 3575610: /*type*/  return new Property("type", "string", "Type for this instance of data.", 0, 1, type);
2193          case 3357091: /*mode*/  return new Property("mode", "code", "Mode for this instance of data.", 0, 1, mode);
2194          case 1587405498: /*documentation*/  return new Property("documentation", "string", "Documentation for this instance of data.", 0, 1, documentation);
2195          default: return super.getNamedProperty(_hash, _name, _checkValid);
2196          }
2197
2198        }
2199
2200      @Override
2201      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2202        switch (hash) {
2203        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // IdType
2204        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // StringType
2205        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<StructureMapInputMode>
2206        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // StringType
2207        default: return super.getProperty(hash, name, checkValid);
2208        }
2209
2210      }
2211
2212      @Override
2213      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2214        switch (hash) {
2215        case 3373707: // name
2216          this.name = TypeConvertor.castToId(value); // IdType
2217          return value;
2218        case 3575610: // type
2219          this.type = TypeConvertor.castToString(value); // StringType
2220          return value;
2221        case 3357091: // mode
2222          value = new StructureMapInputModeEnumFactory().fromType(TypeConvertor.castToCode(value));
2223          this.mode = (Enumeration) value; // Enumeration<StructureMapInputMode>
2224          return value;
2225        case 1587405498: // documentation
2226          this.documentation = TypeConvertor.castToString(value); // StringType
2227          return value;
2228        default: return super.setProperty(hash, name, value);
2229        }
2230
2231      }
2232
2233      @Override
2234      public Base setProperty(String name, Base value) throws FHIRException {
2235        if (name.equals("name")) {
2236          this.name = TypeConvertor.castToId(value); // IdType
2237        } else if (name.equals("type")) {
2238          this.type = TypeConvertor.castToString(value); // StringType
2239        } else if (name.equals("mode")) {
2240          value = new StructureMapInputModeEnumFactory().fromType(TypeConvertor.castToCode(value));
2241          this.mode = (Enumeration) value; // Enumeration<StructureMapInputMode>
2242        } else if (name.equals("documentation")) {
2243          this.documentation = TypeConvertor.castToString(value); // StringType
2244        } else
2245          return super.setProperty(name, value);
2246        return value;
2247      }
2248
2249      @Override
2250      public Base makeProperty(int hash, String name) throws FHIRException {
2251        switch (hash) {
2252        case 3373707:  return getNameElement();
2253        case 3575610:  return getTypeElement();
2254        case 3357091:  return getModeElement();
2255        case 1587405498:  return getDocumentationElement();
2256        default: return super.makeProperty(hash, name);
2257        }
2258
2259      }
2260
2261      @Override
2262      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2263        switch (hash) {
2264        case 3373707: /*name*/ return new String[] {"id"};
2265        case 3575610: /*type*/ return new String[] {"string"};
2266        case 3357091: /*mode*/ return new String[] {"code"};
2267        case 1587405498: /*documentation*/ return new String[] {"string"};
2268        default: return super.getTypesForProperty(hash, name);
2269        }
2270
2271      }
2272
2273      @Override
2274      public Base addChild(String name) throws FHIRException {
2275        if (name.equals("name")) {
2276          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.input.name");
2277        }
2278        else if (name.equals("type")) {
2279          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.input.type");
2280        }
2281        else if (name.equals("mode")) {
2282          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.input.mode");
2283        }
2284        else if (name.equals("documentation")) {
2285          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.input.documentation");
2286        }
2287        else
2288          return super.addChild(name);
2289      }
2290
2291      public StructureMapGroupInputComponent copy() {
2292        StructureMapGroupInputComponent dst = new StructureMapGroupInputComponent();
2293        copyValues(dst);
2294        return dst;
2295      }
2296
2297      public void copyValues(StructureMapGroupInputComponent dst) {
2298        super.copyValues(dst);
2299        dst.name = name == null ? null : name.copy();
2300        dst.type = type == null ? null : type.copy();
2301        dst.mode = mode == null ? null : mode.copy();
2302        dst.documentation = documentation == null ? null : documentation.copy();
2303      }
2304
2305      @Override
2306      public boolean equalsDeep(Base other_) {
2307        if (!super.equalsDeep(other_))
2308          return false;
2309        if (!(other_ instanceof StructureMapGroupInputComponent))
2310          return false;
2311        StructureMapGroupInputComponent o = (StructureMapGroupInputComponent) other_;
2312        return compareDeep(name, o.name, true) && compareDeep(type, o.type, true) && compareDeep(mode, o.mode, true)
2313           && compareDeep(documentation, o.documentation, true);
2314      }
2315
2316      @Override
2317      public boolean equalsShallow(Base other_) {
2318        if (!super.equalsShallow(other_))
2319          return false;
2320        if (!(other_ instanceof StructureMapGroupInputComponent))
2321          return false;
2322        StructureMapGroupInputComponent o = (StructureMapGroupInputComponent) other_;
2323        return compareValues(name, o.name, true) && compareValues(type, o.type, true) && compareValues(mode, o.mode, true)
2324           && compareValues(documentation, o.documentation, true);
2325      }
2326
2327      public boolean isEmpty() {
2328        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, type, mode, documentation
2329          );
2330      }
2331
2332  public String fhirType() {
2333    return "StructureMap.group.input";
2334
2335  }
2336
2337  }
2338
2339    @Block()
2340    public static class StructureMapGroupRuleComponent extends BackboneElement implements IBaseBackboneElement {
2341        /**
2342         * Name of the rule for internal references.
2343         */
2344        @Child(name = "name", type = {IdType.class}, order=1, min=0, max=1, modifier=false, summary=true)
2345        @Description(shortDefinition="Name of the rule for internal references", formalDefinition="Name of the rule for internal references." )
2346        protected IdType name;
2347
2348        /**
2349         * Source inputs to the mapping.
2350         */
2351        @Child(name = "source", type = {}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2352        @Description(shortDefinition="Source inputs to the mapping", formalDefinition="Source inputs to the mapping." )
2353        protected List<StructureMapGroupRuleSourceComponent> source;
2354
2355        /**
2356         * Content to create because of this mapping rule.
2357         */
2358        @Child(name = "target", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2359        @Description(shortDefinition="Content to create because of this mapping rule", formalDefinition="Content to create because of this mapping rule." )
2360        protected List<StructureMapGroupRuleTargetComponent> target;
2361
2362        /**
2363         * Rules contained in this rule.
2364         */
2365        @Child(name = "rule", type = {StructureMapGroupRuleComponent.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2366        @Description(shortDefinition="Rules contained in this rule", formalDefinition="Rules contained in this rule." )
2367        protected List<StructureMapGroupRuleComponent> rule;
2368
2369        /**
2370         * Which other rules to apply in the context of this rule.
2371         */
2372        @Child(name = "dependent", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2373        @Description(shortDefinition="Which other rules to apply in the context of this rule", formalDefinition="Which other rules to apply in the context of this rule." )
2374        protected List<StructureMapGroupRuleDependentComponent> dependent;
2375
2376        /**
2377         * Documentation for this instance of data.
2378         */
2379        @Child(name = "documentation", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=false)
2380        @Description(shortDefinition="Documentation for this instance of data", formalDefinition="Documentation for this instance of data." )
2381        protected StringType documentation;
2382
2383        private static final long serialVersionUID = 773925517L;
2384
2385    /**
2386     * Constructor
2387     */
2388      public StructureMapGroupRuleComponent() {
2389        super();
2390      }
2391
2392    /**
2393     * Constructor
2394     */
2395      public StructureMapGroupRuleComponent(StructureMapGroupRuleSourceComponent source) {
2396        super();
2397        this.addSource(source);
2398      }
2399
2400        /**
2401         * @return {@link #name} (Name of the rule for internal references.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
2402         */
2403        public IdType getNameElement() { 
2404          if (this.name == null)
2405            if (Configuration.errorOnAutoCreate())
2406              throw new Error("Attempt to auto-create StructureMapGroupRuleComponent.name");
2407            else if (Configuration.doAutoCreate())
2408              this.name = new IdType(); // bb
2409          return this.name;
2410        }
2411
2412        public boolean hasNameElement() { 
2413          return this.name != null && !this.name.isEmpty();
2414        }
2415
2416        public boolean hasName() { 
2417          return this.name != null && !this.name.isEmpty();
2418        }
2419
2420        /**
2421         * @param value {@link #name} (Name of the rule for internal references.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
2422         */
2423        public StructureMapGroupRuleComponent setNameElement(IdType value) { 
2424          this.name = value;
2425          return this;
2426        }
2427
2428        /**
2429         * @return Name of the rule for internal references.
2430         */
2431        public String getName() { 
2432          return this.name == null ? null : this.name.getValue();
2433        }
2434
2435        /**
2436         * @param value Name of the rule for internal references.
2437         */
2438        public StructureMapGroupRuleComponent setName(String value) { 
2439          if (Utilities.noString(value))
2440            this.name = null;
2441          else {
2442            if (this.name == null)
2443              this.name = new IdType();
2444            this.name.setValue(value);
2445          }
2446          return this;
2447        }
2448
2449        /**
2450         * @return {@link #source} (Source inputs to the mapping.)
2451         */
2452        public List<StructureMapGroupRuleSourceComponent> getSource() { 
2453          if (this.source == null)
2454            this.source = new ArrayList<StructureMapGroupRuleSourceComponent>();
2455          return this.source;
2456        }
2457
2458        /**
2459         * @return Returns a reference to <code>this</code> for easy method chaining
2460         */
2461        public StructureMapGroupRuleComponent setSource(List<StructureMapGroupRuleSourceComponent> theSource) { 
2462          this.source = theSource;
2463          return this;
2464        }
2465
2466        public boolean hasSource() { 
2467          if (this.source == null)
2468            return false;
2469          for (StructureMapGroupRuleSourceComponent item : this.source)
2470            if (!item.isEmpty())
2471              return true;
2472          return false;
2473        }
2474
2475        public StructureMapGroupRuleSourceComponent addSource() { //3
2476          StructureMapGroupRuleSourceComponent t = new StructureMapGroupRuleSourceComponent();
2477          if (this.source == null)
2478            this.source = new ArrayList<StructureMapGroupRuleSourceComponent>();
2479          this.source.add(t);
2480          return t;
2481        }
2482
2483        public StructureMapGroupRuleComponent addSource(StructureMapGroupRuleSourceComponent t) { //3
2484          if (t == null)
2485            return this;
2486          if (this.source == null)
2487            this.source = new ArrayList<StructureMapGroupRuleSourceComponent>();
2488          this.source.add(t);
2489          return this;
2490        }
2491
2492        /**
2493         * @return The first repetition of repeating field {@link #source}, creating it if it does not already exist {3}
2494         */
2495        public StructureMapGroupRuleSourceComponent getSourceFirstRep() { 
2496          if (getSource().isEmpty()) {
2497            addSource();
2498          }
2499          return getSource().get(0);
2500        }
2501
2502        /**
2503         * @return {@link #target} (Content to create because of this mapping rule.)
2504         */
2505        public List<StructureMapGroupRuleTargetComponent> getTarget() { 
2506          if (this.target == null)
2507            this.target = new ArrayList<StructureMapGroupRuleTargetComponent>();
2508          return this.target;
2509        }
2510
2511        /**
2512         * @return Returns a reference to <code>this</code> for easy method chaining
2513         */
2514        public StructureMapGroupRuleComponent setTarget(List<StructureMapGroupRuleTargetComponent> theTarget) { 
2515          this.target = theTarget;
2516          return this;
2517        }
2518
2519        public boolean hasTarget() { 
2520          if (this.target == null)
2521            return false;
2522          for (StructureMapGroupRuleTargetComponent item : this.target)
2523            if (!item.isEmpty())
2524              return true;
2525          return false;
2526        }
2527
2528        public StructureMapGroupRuleTargetComponent addTarget() { //3
2529          StructureMapGroupRuleTargetComponent t = new StructureMapGroupRuleTargetComponent();
2530          if (this.target == null)
2531            this.target = new ArrayList<StructureMapGroupRuleTargetComponent>();
2532          this.target.add(t);
2533          return t;
2534        }
2535
2536        public StructureMapGroupRuleComponent addTarget(StructureMapGroupRuleTargetComponent t) { //3
2537          if (t == null)
2538            return this;
2539          if (this.target == null)
2540            this.target = new ArrayList<StructureMapGroupRuleTargetComponent>();
2541          this.target.add(t);
2542          return this;
2543        }
2544
2545        /**
2546         * @return The first repetition of repeating field {@link #target}, creating it if it does not already exist {3}
2547         */
2548        public StructureMapGroupRuleTargetComponent getTargetFirstRep() { 
2549          if (getTarget().isEmpty()) {
2550            addTarget();
2551          }
2552          return getTarget().get(0);
2553        }
2554
2555        /**
2556         * @return {@link #rule} (Rules contained in this rule.)
2557         */
2558        public List<StructureMapGroupRuleComponent> getRule() { 
2559          if (this.rule == null)
2560            this.rule = new ArrayList<StructureMapGroupRuleComponent>();
2561          return this.rule;
2562        }
2563
2564        /**
2565         * @return Returns a reference to <code>this</code> for easy method chaining
2566         */
2567        public StructureMapGroupRuleComponent setRule(List<StructureMapGroupRuleComponent> theRule) { 
2568          this.rule = theRule;
2569          return this;
2570        }
2571
2572        public boolean hasRule() { 
2573          if (this.rule == null)
2574            return false;
2575          for (StructureMapGroupRuleComponent item : this.rule)
2576            if (!item.isEmpty())
2577              return true;
2578          return false;
2579        }
2580
2581        public StructureMapGroupRuleComponent addRule() { //3
2582          StructureMapGroupRuleComponent t = new StructureMapGroupRuleComponent();
2583          if (this.rule == null)
2584            this.rule = new ArrayList<StructureMapGroupRuleComponent>();
2585          this.rule.add(t);
2586          return t;
2587        }
2588
2589        public StructureMapGroupRuleComponent addRule(StructureMapGroupRuleComponent t) { //3
2590          if (t == null)
2591            return this;
2592          if (this.rule == null)
2593            this.rule = new ArrayList<StructureMapGroupRuleComponent>();
2594          this.rule.add(t);
2595          return this;
2596        }
2597
2598        /**
2599         * @return The first repetition of repeating field {@link #rule}, creating it if it does not already exist {3}
2600         */
2601        public StructureMapGroupRuleComponent getRuleFirstRep() { 
2602          if (getRule().isEmpty()) {
2603            addRule();
2604          }
2605          return getRule().get(0);
2606        }
2607
2608        /**
2609         * @return {@link #dependent} (Which other rules to apply in the context of this rule.)
2610         */
2611        public List<StructureMapGroupRuleDependentComponent> getDependent() { 
2612          if (this.dependent == null)
2613            this.dependent = new ArrayList<StructureMapGroupRuleDependentComponent>();
2614          return this.dependent;
2615        }
2616
2617        /**
2618         * @return Returns a reference to <code>this</code> for easy method chaining
2619         */
2620        public StructureMapGroupRuleComponent setDependent(List<StructureMapGroupRuleDependentComponent> theDependent) { 
2621          this.dependent = theDependent;
2622          return this;
2623        }
2624
2625        public boolean hasDependent() { 
2626          if (this.dependent == null)
2627            return false;
2628          for (StructureMapGroupRuleDependentComponent item : this.dependent)
2629            if (!item.isEmpty())
2630              return true;
2631          return false;
2632        }
2633
2634        public StructureMapGroupRuleDependentComponent addDependent() { //3
2635          StructureMapGroupRuleDependentComponent t = new StructureMapGroupRuleDependentComponent();
2636          if (this.dependent == null)
2637            this.dependent = new ArrayList<StructureMapGroupRuleDependentComponent>();
2638          this.dependent.add(t);
2639          return t;
2640        }
2641
2642        public StructureMapGroupRuleComponent addDependent(StructureMapGroupRuleDependentComponent t) { //3
2643          if (t == null)
2644            return this;
2645          if (this.dependent == null)
2646            this.dependent = new ArrayList<StructureMapGroupRuleDependentComponent>();
2647          this.dependent.add(t);
2648          return this;
2649        }
2650
2651        /**
2652         * @return The first repetition of repeating field {@link #dependent}, creating it if it does not already exist {3}
2653         */
2654        public StructureMapGroupRuleDependentComponent getDependentFirstRep() { 
2655          if (getDependent().isEmpty()) {
2656            addDependent();
2657          }
2658          return getDependent().get(0);
2659        }
2660
2661        /**
2662         * @return {@link #documentation} (Documentation for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
2663         */
2664        public StringType getDocumentationElement() { 
2665          if (this.documentation == null)
2666            if (Configuration.errorOnAutoCreate())
2667              throw new Error("Attempt to auto-create StructureMapGroupRuleComponent.documentation");
2668            else if (Configuration.doAutoCreate())
2669              this.documentation = new StringType(); // bb
2670          return this.documentation;
2671        }
2672
2673        public boolean hasDocumentationElement() { 
2674          return this.documentation != null && !this.documentation.isEmpty();
2675        }
2676
2677        public boolean hasDocumentation() { 
2678          return this.documentation != null && !this.documentation.isEmpty();
2679        }
2680
2681        /**
2682         * @param value {@link #documentation} (Documentation for this instance of data.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
2683         */
2684        public StructureMapGroupRuleComponent setDocumentationElement(StringType value) { 
2685          this.documentation = value;
2686          return this;
2687        }
2688
2689        /**
2690         * @return Documentation for this instance of data.
2691         */
2692        public String getDocumentation() { 
2693          return this.documentation == null ? null : this.documentation.getValue();
2694        }
2695
2696        /**
2697         * @param value Documentation for this instance of data.
2698         */
2699        public StructureMapGroupRuleComponent setDocumentation(String value) { 
2700          if (Utilities.noString(value))
2701            this.documentation = null;
2702          else {
2703            if (this.documentation == null)
2704              this.documentation = new StringType();
2705            this.documentation.setValue(value);
2706          }
2707          return this;
2708        }
2709
2710        protected void listChildren(List<Property> children) {
2711          super.listChildren(children);
2712          children.add(new Property("name", "id", "Name of the rule for internal references.", 0, 1, name));
2713          children.add(new Property("source", "", "Source inputs to the mapping.", 0, java.lang.Integer.MAX_VALUE, source));
2714          children.add(new Property("target", "", "Content to create because of this mapping rule.", 0, java.lang.Integer.MAX_VALUE, target));
2715          children.add(new Property("rule", "@StructureMap.group.rule", "Rules contained in this rule.", 0, java.lang.Integer.MAX_VALUE, rule));
2716          children.add(new Property("dependent", "", "Which other rules to apply in the context of this rule.", 0, java.lang.Integer.MAX_VALUE, dependent));
2717          children.add(new Property("documentation", "string", "Documentation for this instance of data.", 0, 1, documentation));
2718        }
2719
2720        @Override
2721        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2722          switch (_hash) {
2723          case 3373707: /*name*/  return new Property("name", "id", "Name of the rule for internal references.", 0, 1, name);
2724          case -896505829: /*source*/  return new Property("source", "", "Source inputs to the mapping.", 0, java.lang.Integer.MAX_VALUE, source);
2725          case -880905839: /*target*/  return new Property("target", "", "Content to create because of this mapping rule.", 0, java.lang.Integer.MAX_VALUE, target);
2726          case 3512060: /*rule*/  return new Property("rule", "@StructureMap.group.rule", "Rules contained in this rule.", 0, java.lang.Integer.MAX_VALUE, rule);
2727          case -1109226753: /*dependent*/  return new Property("dependent", "", "Which other rules to apply in the context of this rule.", 0, java.lang.Integer.MAX_VALUE, dependent);
2728          case 1587405498: /*documentation*/  return new Property("documentation", "string", "Documentation for this instance of data.", 0, 1, documentation);
2729          default: return super.getNamedProperty(_hash, _name, _checkValid);
2730          }
2731
2732        }
2733
2734      @Override
2735      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2736        switch (hash) {
2737        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // IdType
2738        case -896505829: /*source*/ return this.source == null ? new Base[0] : this.source.toArray(new Base[this.source.size()]); // StructureMapGroupRuleSourceComponent
2739        case -880905839: /*target*/ return this.target == null ? new Base[0] : this.target.toArray(new Base[this.target.size()]); // StructureMapGroupRuleTargetComponent
2740        case 3512060: /*rule*/ return this.rule == null ? new Base[0] : this.rule.toArray(new Base[this.rule.size()]); // StructureMapGroupRuleComponent
2741        case -1109226753: /*dependent*/ return this.dependent == null ? new Base[0] : this.dependent.toArray(new Base[this.dependent.size()]); // StructureMapGroupRuleDependentComponent
2742        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // StringType
2743        default: return super.getProperty(hash, name, checkValid);
2744        }
2745
2746      }
2747
2748      @Override
2749      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2750        switch (hash) {
2751        case 3373707: // name
2752          this.name = TypeConvertor.castToId(value); // IdType
2753          return value;
2754        case -896505829: // source
2755          this.getSource().add((StructureMapGroupRuleSourceComponent) value); // StructureMapGroupRuleSourceComponent
2756          return value;
2757        case -880905839: // target
2758          this.getTarget().add((StructureMapGroupRuleTargetComponent) value); // StructureMapGroupRuleTargetComponent
2759          return value;
2760        case 3512060: // rule
2761          this.getRule().add((StructureMapGroupRuleComponent) value); // StructureMapGroupRuleComponent
2762          return value;
2763        case -1109226753: // dependent
2764          this.getDependent().add((StructureMapGroupRuleDependentComponent) value); // StructureMapGroupRuleDependentComponent
2765          return value;
2766        case 1587405498: // documentation
2767          this.documentation = TypeConvertor.castToString(value); // StringType
2768          return value;
2769        default: return super.setProperty(hash, name, value);
2770        }
2771
2772      }
2773
2774      @Override
2775      public Base setProperty(String name, Base value) throws FHIRException {
2776        if (name.equals("name")) {
2777          this.name = TypeConvertor.castToId(value); // IdType
2778        } else if (name.equals("source")) {
2779          this.getSource().add((StructureMapGroupRuleSourceComponent) value);
2780        } else if (name.equals("target")) {
2781          this.getTarget().add((StructureMapGroupRuleTargetComponent) value);
2782        } else if (name.equals("rule")) {
2783          this.getRule().add((StructureMapGroupRuleComponent) value);
2784        } else if (name.equals("dependent")) {
2785          this.getDependent().add((StructureMapGroupRuleDependentComponent) value);
2786        } else if (name.equals("documentation")) {
2787          this.documentation = TypeConvertor.castToString(value); // StringType
2788        } else
2789          return super.setProperty(name, value);
2790        return value;
2791      }
2792
2793      @Override
2794      public Base makeProperty(int hash, String name) throws FHIRException {
2795        switch (hash) {
2796        case 3373707:  return getNameElement();
2797        case -896505829:  return addSource(); 
2798        case -880905839:  return addTarget(); 
2799        case 3512060:  return addRule(); 
2800        case -1109226753:  return addDependent(); 
2801        case 1587405498:  return getDocumentationElement();
2802        default: return super.makeProperty(hash, name);
2803        }
2804
2805      }
2806
2807      @Override
2808      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2809        switch (hash) {
2810        case 3373707: /*name*/ return new String[] {"id"};
2811        case -896505829: /*source*/ return new String[] {};
2812        case -880905839: /*target*/ return new String[] {};
2813        case 3512060: /*rule*/ return new String[] {"@StructureMap.group.rule"};
2814        case -1109226753: /*dependent*/ return new String[] {};
2815        case 1587405498: /*documentation*/ return new String[] {"string"};
2816        default: return super.getTypesForProperty(hash, name);
2817        }
2818
2819      }
2820
2821      @Override
2822      public Base addChild(String name) throws FHIRException {
2823        if (name.equals("name")) {
2824          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.name");
2825        }
2826        else if (name.equals("source")) {
2827          return addSource();
2828        }
2829        else if (name.equals("target")) {
2830          return addTarget();
2831        }
2832        else if (name.equals("rule")) {
2833          return addRule();
2834        }
2835        else if (name.equals("dependent")) {
2836          return addDependent();
2837        }
2838        else if (name.equals("documentation")) {
2839          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.documentation");
2840        }
2841        else
2842          return super.addChild(name);
2843      }
2844
2845      public StructureMapGroupRuleComponent copy() {
2846        StructureMapGroupRuleComponent dst = new StructureMapGroupRuleComponent();
2847        copyValues(dst);
2848        return dst;
2849      }
2850
2851      public void copyValues(StructureMapGroupRuleComponent dst) {
2852        super.copyValues(dst);
2853        dst.name = name == null ? null : name.copy();
2854        if (source != null) {
2855          dst.source = new ArrayList<StructureMapGroupRuleSourceComponent>();
2856          for (StructureMapGroupRuleSourceComponent i : source)
2857            dst.source.add(i.copy());
2858        };
2859        if (target != null) {
2860          dst.target = new ArrayList<StructureMapGroupRuleTargetComponent>();
2861          for (StructureMapGroupRuleTargetComponent i : target)
2862            dst.target.add(i.copy());
2863        };
2864        if (rule != null) {
2865          dst.rule = new ArrayList<StructureMapGroupRuleComponent>();
2866          for (StructureMapGroupRuleComponent i : rule)
2867            dst.rule.add(i.copy());
2868        };
2869        if (dependent != null) {
2870          dst.dependent = new ArrayList<StructureMapGroupRuleDependentComponent>();
2871          for (StructureMapGroupRuleDependentComponent i : dependent)
2872            dst.dependent.add(i.copy());
2873        };
2874        dst.documentation = documentation == null ? null : documentation.copy();
2875      }
2876
2877      @Override
2878      public boolean equalsDeep(Base other_) {
2879        if (!super.equalsDeep(other_))
2880          return false;
2881        if (!(other_ instanceof StructureMapGroupRuleComponent))
2882          return false;
2883        StructureMapGroupRuleComponent o = (StructureMapGroupRuleComponent) other_;
2884        return compareDeep(name, o.name, true) && compareDeep(source, o.source, true) && compareDeep(target, o.target, true)
2885           && compareDeep(rule, o.rule, true) && compareDeep(dependent, o.dependent, true) && compareDeep(documentation, o.documentation, true)
2886          ;
2887      }
2888
2889      @Override
2890      public boolean equalsShallow(Base other_) {
2891        if (!super.equalsShallow(other_))
2892          return false;
2893        if (!(other_ instanceof StructureMapGroupRuleComponent))
2894          return false;
2895        StructureMapGroupRuleComponent o = (StructureMapGroupRuleComponent) other_;
2896        return compareValues(name, o.name, true) && compareValues(documentation, o.documentation, true);
2897      }
2898
2899      public boolean isEmpty() {
2900        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, source, target, rule
2901          , dependent, documentation);
2902      }
2903
2904  public String fhirType() {
2905    return "StructureMap.group.rule";
2906
2907  }
2908
2909// added from java-adornments.txt:
2910public String toString() {
2911    return StructureMapUtilities.ruleToString(this);
2912  }
2913// end addition
2914  }
2915
2916    @Block()
2917    public static class StructureMapGroupRuleSourceComponent extends BackboneElement implements IBaseBackboneElement {
2918        /**
2919         * Type or variable this rule applies to.
2920         */
2921        @Child(name = "context", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true)
2922        @Description(shortDefinition="Type or variable this rule applies to", formalDefinition="Type or variable this rule applies to." )
2923        protected IdType context;
2924
2925        /**
2926         * Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.
2927         */
2928        @Child(name = "min", type = {IntegerType.class}, order=2, min=0, max=1, modifier=false, summary=true)
2929        @Description(shortDefinition="Specified minimum cardinality", formalDefinition="Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content." )
2930        protected IntegerType min;
2931
2932        /**
2933         * Specified maximum cardinality for the element - a number or a "*". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).
2934         */
2935        @Child(name = "max", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true)
2936        @Description(shortDefinition="Specified maximum cardinality (number or *)", formalDefinition="Specified maximum cardinality for the element - a number or a \"*\". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value)." )
2937        protected StringType max;
2938
2939        /**
2940         * Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.
2941         */
2942        @Child(name = "type", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
2943        @Description(shortDefinition="Rule only applies if source has this type", formalDefinition="Specified type for the element. This works as a condition on the mapping - use for polymorphic elements." )
2944        protected StringType type;
2945
2946        /**
2947         * A value to use if there is no existing value in the source object.
2948         */
2949        @Child(name = "defaultValue", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
2950        @Description(shortDefinition="Default value if no value exists", formalDefinition="A value to use if there is no existing value in the source object." )
2951        protected StringType defaultValue;
2952
2953        /**
2954         * Optional field for this source.
2955         */
2956        @Child(name = "element", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=true)
2957        @Description(shortDefinition="Optional field for this source", formalDefinition="Optional field for this source." )
2958        protected StringType element;
2959
2960        /**
2961         * How to handle the list mode for this element.
2962         */
2963        @Child(name = "listMode", type = {CodeType.class}, order=7, min=0, max=1, modifier=false, summary=true)
2964        @Description(shortDefinition="first | not_first | last | not_last | only_one", formalDefinition="How to handle the list mode for this element." )
2965        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/map-source-list-mode")
2966        protected Enumeration<StructureMapSourceListMode> listMode;
2967
2968        /**
2969         * Named context for field, if a field is specified.
2970         */
2971        @Child(name = "variable", type = {IdType.class}, order=8, min=0, max=1, modifier=false, summary=true)
2972        @Description(shortDefinition="Named context for field, if a field is specified", formalDefinition="Named context for field, if a field is specified." )
2973        protected IdType variable;
2974
2975        /**
2976         * FHIRPath expression  - must be true or the rule does not apply.
2977         */
2978        @Child(name = "condition", type = {StringType.class}, order=9, min=0, max=1, modifier=false, summary=true)
2979        @Description(shortDefinition="FHIRPath expression  - must be true or the rule does not apply", formalDefinition="FHIRPath expression  - must be true or the rule does not apply." )
2980        protected StringType condition;
2981
2982        /**
2983         * FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.
2984         */
2985        @Child(name = "check", type = {StringType.class}, order=10, min=0, max=1, modifier=false, summary=true)
2986        @Description(shortDefinition="FHIRPath expression  - must be true or the mapping engine throws an error instead of completing", formalDefinition="FHIRPath expression  - must be true or the mapping engine throws an error instead of completing." )
2987        protected StringType check;
2988
2989        /**
2990         * A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.
2991         */
2992        @Child(name = "logMessage", type = {StringType.class}, order=11, min=0, max=1, modifier=false, summary=true)
2993        @Description(shortDefinition="Message to put in log if source exists (FHIRPath)", formalDefinition="A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found." )
2994        protected StringType logMessage;
2995
2996        private static final long serialVersionUID = 214178119L;
2997
2998    /**
2999     * Constructor
3000     */
3001      public StructureMapGroupRuleSourceComponent() {
3002        super();
3003      }
3004
3005    /**
3006     * Constructor
3007     */
3008      public StructureMapGroupRuleSourceComponent(String context) {
3009        super();
3010        this.setContext(context);
3011      }
3012
3013        /**
3014         * @return {@link #context} (Type or variable this rule applies to.). This is the underlying object with id, value and extensions. The accessor "getContext" gives direct access to the value
3015         */
3016        public IdType getContextElement() { 
3017          if (this.context == null)
3018            if (Configuration.errorOnAutoCreate())
3019              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.context");
3020            else if (Configuration.doAutoCreate())
3021              this.context = new IdType(); // bb
3022          return this.context;
3023        }
3024
3025        public boolean hasContextElement() { 
3026          return this.context != null && !this.context.isEmpty();
3027        }
3028
3029        public boolean hasContext() { 
3030          return this.context != null && !this.context.isEmpty();
3031        }
3032
3033        /**
3034         * @param value {@link #context} (Type or variable this rule applies to.). This is the underlying object with id, value and extensions. The accessor "getContext" gives direct access to the value
3035         */
3036        public StructureMapGroupRuleSourceComponent setContextElement(IdType value) { 
3037          this.context = value;
3038          return this;
3039        }
3040
3041        /**
3042         * @return Type or variable this rule applies to.
3043         */
3044        public String getContext() { 
3045          return this.context == null ? null : this.context.getValue();
3046        }
3047
3048        /**
3049         * @param value Type or variable this rule applies to.
3050         */
3051        public StructureMapGroupRuleSourceComponent setContext(String value) { 
3052            if (this.context == null)
3053              this.context = new IdType();
3054            this.context.setValue(value);
3055          return this;
3056        }
3057
3058        /**
3059         * @return {@link #min} (Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
3060         */
3061        public IntegerType getMinElement() { 
3062          if (this.min == null)
3063            if (Configuration.errorOnAutoCreate())
3064              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.min");
3065            else if (Configuration.doAutoCreate())
3066              this.min = new IntegerType(); // bb
3067          return this.min;
3068        }
3069
3070        public boolean hasMinElement() { 
3071          return this.min != null && !this.min.isEmpty();
3072        }
3073
3074        public boolean hasMin() { 
3075          return this.min != null && !this.min.isEmpty();
3076        }
3077
3078        /**
3079         * @param value {@link #min} (Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.). This is the underlying object with id, value and extensions. The accessor "getMin" gives direct access to the value
3080         */
3081        public StructureMapGroupRuleSourceComponent setMinElement(IntegerType value) { 
3082          this.min = value;
3083          return this;
3084        }
3085
3086        /**
3087         * @return Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.
3088         */
3089        public int getMin() { 
3090          return this.min == null || this.min.isEmpty() ? 0 : this.min.getValue();
3091        }
3092
3093        /**
3094         * @param value Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.
3095         */
3096        public StructureMapGroupRuleSourceComponent setMin(int value) { 
3097            if (this.min == null)
3098              this.min = new IntegerType();
3099            this.min.setValue(value);
3100          return this;
3101        }
3102
3103        /**
3104         * @return {@link #max} (Specified maximum cardinality for the element - a number or a "*". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
3105         */
3106        public StringType getMaxElement() { 
3107          if (this.max == null)
3108            if (Configuration.errorOnAutoCreate())
3109              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.max");
3110            else if (Configuration.doAutoCreate())
3111              this.max = new StringType(); // bb
3112          return this.max;
3113        }
3114
3115        public boolean hasMaxElement() { 
3116          return this.max != null && !this.max.isEmpty();
3117        }
3118
3119        public boolean hasMax() { 
3120          return this.max != null && !this.max.isEmpty();
3121        }
3122
3123        /**
3124         * @param value {@link #max} (Specified maximum cardinality for the element - a number or a "*". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).). This is the underlying object with id, value and extensions. The accessor "getMax" gives direct access to the value
3125         */
3126        public StructureMapGroupRuleSourceComponent setMaxElement(StringType value) { 
3127          this.max = value;
3128          return this;
3129        }
3130
3131        /**
3132         * @return Specified maximum cardinality for the element - a number or a "*". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).
3133         */
3134        public String getMax() { 
3135          return this.max == null ? null : this.max.getValue();
3136        }
3137
3138        /**
3139         * @param value Specified maximum cardinality for the element - a number or a "*". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).
3140         */
3141        public StructureMapGroupRuleSourceComponent setMax(String value) { 
3142          if (Utilities.noString(value))
3143            this.max = null;
3144          else {
3145            if (this.max == null)
3146              this.max = new StringType();
3147            this.max.setValue(value);
3148          }
3149          return this;
3150        }
3151
3152        /**
3153         * @return {@link #type} (Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
3154         */
3155        public StringType getTypeElement() { 
3156          if (this.type == null)
3157            if (Configuration.errorOnAutoCreate())
3158              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.type");
3159            else if (Configuration.doAutoCreate())
3160              this.type = new StringType(); // bb
3161          return this.type;
3162        }
3163
3164        public boolean hasTypeElement() { 
3165          return this.type != null && !this.type.isEmpty();
3166        }
3167
3168        public boolean hasType() { 
3169          return this.type != null && !this.type.isEmpty();
3170        }
3171
3172        /**
3173         * @param value {@link #type} (Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
3174         */
3175        public StructureMapGroupRuleSourceComponent setTypeElement(StringType value) { 
3176          this.type = value;
3177          return this;
3178        }
3179
3180        /**
3181         * @return Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.
3182         */
3183        public String getType() { 
3184          return this.type == null ? null : this.type.getValue();
3185        }
3186
3187        /**
3188         * @param value Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.
3189         */
3190        public StructureMapGroupRuleSourceComponent setType(String value) { 
3191          if (Utilities.noString(value))
3192            this.type = null;
3193          else {
3194            if (this.type == null)
3195              this.type = new StringType();
3196            this.type.setValue(value);
3197          }
3198          return this;
3199        }
3200
3201        /**
3202         * @return {@link #defaultValue} (A value to use if there is no existing value in the source object.). This is the underlying object with id, value and extensions. The accessor "getDefaultValue" gives direct access to the value
3203         */
3204        public StringType getDefaultValueElement() { 
3205          if (this.defaultValue == null)
3206            if (Configuration.errorOnAutoCreate())
3207              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.defaultValue");
3208            else if (Configuration.doAutoCreate())
3209              this.defaultValue = new StringType(); // bb
3210          return this.defaultValue;
3211        }
3212
3213        public boolean hasDefaultValueElement() { 
3214          return this.defaultValue != null && !this.defaultValue.isEmpty();
3215        }
3216
3217        public boolean hasDefaultValue() { 
3218          return this.defaultValue != null && !this.defaultValue.isEmpty();
3219        }
3220
3221        /**
3222         * @param value {@link #defaultValue} (A value to use if there is no existing value in the source object.). This is the underlying object with id, value and extensions. The accessor "getDefaultValue" gives direct access to the value
3223         */
3224        public StructureMapGroupRuleSourceComponent setDefaultValueElement(StringType value) { 
3225          this.defaultValue = value;
3226          return this;
3227        }
3228
3229        /**
3230         * @return A value to use if there is no existing value in the source object.
3231         */
3232        public String getDefaultValue() { 
3233          return this.defaultValue == null ? null : this.defaultValue.getValue();
3234        }
3235
3236        /**
3237         * @param value A value to use if there is no existing value in the source object.
3238         */
3239        public StructureMapGroupRuleSourceComponent setDefaultValue(String value) { 
3240          if (Utilities.noString(value))
3241            this.defaultValue = null;
3242          else {
3243            if (this.defaultValue == null)
3244              this.defaultValue = new StringType();
3245            this.defaultValue.setValue(value);
3246          }
3247          return this;
3248        }
3249
3250        /**
3251         * @return {@link #element} (Optional field for this source.). This is the underlying object with id, value and extensions. The accessor "getElement" gives direct access to the value
3252         */
3253        public StringType getElementElement() { 
3254          if (this.element == null)
3255            if (Configuration.errorOnAutoCreate())
3256              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.element");
3257            else if (Configuration.doAutoCreate())
3258              this.element = new StringType(); // bb
3259          return this.element;
3260        }
3261
3262        public boolean hasElementElement() { 
3263          return this.element != null && !this.element.isEmpty();
3264        }
3265
3266        public boolean hasElement() { 
3267          return this.element != null && !this.element.isEmpty();
3268        }
3269
3270        /**
3271         * @param value {@link #element} (Optional field for this source.). This is the underlying object with id, value and extensions. The accessor "getElement" gives direct access to the value
3272         */
3273        public StructureMapGroupRuleSourceComponent setElementElement(StringType value) { 
3274          this.element = value;
3275          return this;
3276        }
3277
3278        /**
3279         * @return Optional field for this source.
3280         */
3281        public String getElement() { 
3282          return this.element == null ? null : this.element.getValue();
3283        }
3284
3285        /**
3286         * @param value Optional field for this source.
3287         */
3288        public StructureMapGroupRuleSourceComponent setElement(String value) { 
3289          if (Utilities.noString(value))
3290            this.element = null;
3291          else {
3292            if (this.element == null)
3293              this.element = new StringType();
3294            this.element.setValue(value);
3295          }
3296          return this;
3297        }
3298
3299        /**
3300         * @return {@link #listMode} (How to handle the list mode for this element.). This is the underlying object with id, value and extensions. The accessor "getListMode" gives direct access to the value
3301         */
3302        public Enumeration<StructureMapSourceListMode> getListModeElement() { 
3303          if (this.listMode == null)
3304            if (Configuration.errorOnAutoCreate())
3305              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.listMode");
3306            else if (Configuration.doAutoCreate())
3307              this.listMode = new Enumeration<StructureMapSourceListMode>(new StructureMapSourceListModeEnumFactory()); // bb
3308          return this.listMode;
3309        }
3310
3311        public boolean hasListModeElement() { 
3312          return this.listMode != null && !this.listMode.isEmpty();
3313        }
3314
3315        public boolean hasListMode() { 
3316          return this.listMode != null && !this.listMode.isEmpty();
3317        }
3318
3319        /**
3320         * @param value {@link #listMode} (How to handle the list mode for this element.). This is the underlying object with id, value and extensions. The accessor "getListMode" gives direct access to the value
3321         */
3322        public StructureMapGroupRuleSourceComponent setListModeElement(Enumeration<StructureMapSourceListMode> value) { 
3323          this.listMode = value;
3324          return this;
3325        }
3326
3327        /**
3328         * @return How to handle the list mode for this element.
3329         */
3330        public StructureMapSourceListMode getListMode() { 
3331          return this.listMode == null ? null : this.listMode.getValue();
3332        }
3333
3334        /**
3335         * @param value How to handle the list mode for this element.
3336         */
3337        public StructureMapGroupRuleSourceComponent setListMode(StructureMapSourceListMode value) { 
3338          if (value == null)
3339            this.listMode = null;
3340          else {
3341            if (this.listMode == null)
3342              this.listMode = new Enumeration<StructureMapSourceListMode>(new StructureMapSourceListModeEnumFactory());
3343            this.listMode.setValue(value);
3344          }
3345          return this;
3346        }
3347
3348        /**
3349         * @return {@link #variable} (Named context for field, if a field is specified.). This is the underlying object with id, value and extensions. The accessor "getVariable" gives direct access to the value
3350         */
3351        public IdType getVariableElement() { 
3352          if (this.variable == null)
3353            if (Configuration.errorOnAutoCreate())
3354              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.variable");
3355            else if (Configuration.doAutoCreate())
3356              this.variable = new IdType(); // bb
3357          return this.variable;
3358        }
3359
3360        public boolean hasVariableElement() { 
3361          return this.variable != null && !this.variable.isEmpty();
3362        }
3363
3364        public boolean hasVariable() { 
3365          return this.variable != null && !this.variable.isEmpty();
3366        }
3367
3368        /**
3369         * @param value {@link #variable} (Named context for field, if a field is specified.). This is the underlying object with id, value and extensions. The accessor "getVariable" gives direct access to the value
3370         */
3371        public StructureMapGroupRuleSourceComponent setVariableElement(IdType value) { 
3372          this.variable = value;
3373          return this;
3374        }
3375
3376        /**
3377         * @return Named context for field, if a field is specified.
3378         */
3379        public String getVariable() { 
3380          return this.variable == null ? null : this.variable.getValue();
3381        }
3382
3383        /**
3384         * @param value Named context for field, if a field is specified.
3385         */
3386        public StructureMapGroupRuleSourceComponent setVariable(String value) { 
3387          if (Utilities.noString(value))
3388            this.variable = null;
3389          else {
3390            if (this.variable == null)
3391              this.variable = new IdType();
3392            this.variable.setValue(value);
3393          }
3394          return this;
3395        }
3396
3397        /**
3398         * @return {@link #condition} (FHIRPath expression  - must be true or the rule does not apply.). This is the underlying object with id, value and extensions. The accessor "getCondition" gives direct access to the value
3399         */
3400        public StringType getConditionElement() { 
3401          if (this.condition == null)
3402            if (Configuration.errorOnAutoCreate())
3403              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.condition");
3404            else if (Configuration.doAutoCreate())
3405              this.condition = new StringType(); // bb
3406          return this.condition;
3407        }
3408
3409        public boolean hasConditionElement() { 
3410          return this.condition != null && !this.condition.isEmpty();
3411        }
3412
3413        public boolean hasCondition() { 
3414          return this.condition != null && !this.condition.isEmpty();
3415        }
3416
3417        /**
3418         * @param value {@link #condition} (FHIRPath expression  - must be true or the rule does not apply.). This is the underlying object with id, value and extensions. The accessor "getCondition" gives direct access to the value
3419         */
3420        public StructureMapGroupRuleSourceComponent setConditionElement(StringType value) { 
3421          this.condition = value;
3422          return this;
3423        }
3424
3425        /**
3426         * @return FHIRPath expression  - must be true or the rule does not apply.
3427         */
3428        public String getCondition() { 
3429          return this.condition == null ? null : this.condition.getValue();
3430        }
3431
3432        /**
3433         * @param value FHIRPath expression  - must be true or the rule does not apply.
3434         */
3435        public StructureMapGroupRuleSourceComponent setCondition(String value) { 
3436          if (Utilities.noString(value))
3437            this.condition = null;
3438          else {
3439            if (this.condition == null)
3440              this.condition = new StringType();
3441            this.condition.setValue(value);
3442          }
3443          return this;
3444        }
3445
3446        /**
3447         * @return {@link #check} (FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.). This is the underlying object with id, value and extensions. The accessor "getCheck" gives direct access to the value
3448         */
3449        public StringType getCheckElement() { 
3450          if (this.check == null)
3451            if (Configuration.errorOnAutoCreate())
3452              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.check");
3453            else if (Configuration.doAutoCreate())
3454              this.check = new StringType(); // bb
3455          return this.check;
3456        }
3457
3458        public boolean hasCheckElement() { 
3459          return this.check != null && !this.check.isEmpty();
3460        }
3461
3462        public boolean hasCheck() { 
3463          return this.check != null && !this.check.isEmpty();
3464        }
3465
3466        /**
3467         * @param value {@link #check} (FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.). This is the underlying object with id, value and extensions. The accessor "getCheck" gives direct access to the value
3468         */
3469        public StructureMapGroupRuleSourceComponent setCheckElement(StringType value) { 
3470          this.check = value;
3471          return this;
3472        }
3473
3474        /**
3475         * @return FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.
3476         */
3477        public String getCheck() { 
3478          return this.check == null ? null : this.check.getValue();
3479        }
3480
3481        /**
3482         * @param value FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.
3483         */
3484        public StructureMapGroupRuleSourceComponent setCheck(String value) { 
3485          if (Utilities.noString(value))
3486            this.check = null;
3487          else {
3488            if (this.check == null)
3489              this.check = new StringType();
3490            this.check.setValue(value);
3491          }
3492          return this;
3493        }
3494
3495        /**
3496         * @return {@link #logMessage} (A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.). This is the underlying object with id, value and extensions. The accessor "getLogMessage" gives direct access to the value
3497         */
3498        public StringType getLogMessageElement() { 
3499          if (this.logMessage == null)
3500            if (Configuration.errorOnAutoCreate())
3501              throw new Error("Attempt to auto-create StructureMapGroupRuleSourceComponent.logMessage");
3502            else if (Configuration.doAutoCreate())
3503              this.logMessage = new StringType(); // bb
3504          return this.logMessage;
3505        }
3506
3507        public boolean hasLogMessageElement() { 
3508          return this.logMessage != null && !this.logMessage.isEmpty();
3509        }
3510
3511        public boolean hasLogMessage() { 
3512          return this.logMessage != null && !this.logMessage.isEmpty();
3513        }
3514
3515        /**
3516         * @param value {@link #logMessage} (A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.). This is the underlying object with id, value and extensions. The accessor "getLogMessage" gives direct access to the value
3517         */
3518        public StructureMapGroupRuleSourceComponent setLogMessageElement(StringType value) { 
3519          this.logMessage = value;
3520          return this;
3521        }
3522
3523        /**
3524         * @return A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.
3525         */
3526        public String getLogMessage() { 
3527          return this.logMessage == null ? null : this.logMessage.getValue();
3528        }
3529
3530        /**
3531         * @param value A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.
3532         */
3533        public StructureMapGroupRuleSourceComponent setLogMessage(String value) { 
3534          if (Utilities.noString(value))
3535            this.logMessage = null;
3536          else {
3537            if (this.logMessage == null)
3538              this.logMessage = new StringType();
3539            this.logMessage.setValue(value);
3540          }
3541          return this;
3542        }
3543
3544        protected void listChildren(List<Property> children) {
3545          super.listChildren(children);
3546          children.add(new Property("context", "id", "Type or variable this rule applies to.", 0, 1, context));
3547          children.add(new Property("min", "integer", "Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.", 0, 1, min));
3548          children.add(new Property("max", "string", "Specified maximum cardinality for the element - a number or a \"*\". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).", 0, 1, max));
3549          children.add(new Property("type", "string", "Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.", 0, 1, type));
3550          children.add(new Property("defaultValue", "string", "A value to use if there is no existing value in the source object.", 0, 1, defaultValue));
3551          children.add(new Property("element", "string", "Optional field for this source.", 0, 1, element));
3552          children.add(new Property("listMode", "code", "How to handle the list mode for this element.", 0, 1, listMode));
3553          children.add(new Property("variable", "id", "Named context for field, if a field is specified.", 0, 1, variable));
3554          children.add(new Property("condition", "string", "FHIRPath expression  - must be true or the rule does not apply.", 0, 1, condition));
3555          children.add(new Property("check", "string", "FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.", 0, 1, check));
3556          children.add(new Property("logMessage", "string", "A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.", 0, 1, logMessage));
3557        }
3558
3559        @Override
3560        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3561          switch (_hash) {
3562          case 951530927: /*context*/  return new Property("context", "id", "Type or variable this rule applies to.", 0, 1, context);
3563          case 108114: /*min*/  return new Property("min", "integer", "Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.", 0, 1, min);
3564          case 107876: /*max*/  return new Property("max", "string", "Specified maximum cardinality for the element - a number or a \"*\". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).", 0, 1, max);
3565          case 3575610: /*type*/  return new Property("type", "string", "Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.", 0, 1, type);
3566          case -659125328: /*defaultValue*/  return new Property("defaultValue", "string", "A value to use if there is no existing value in the source object.", 0, 1, defaultValue);
3567          case -1662836996: /*element*/  return new Property("element", "string", "Optional field for this source.", 0, 1, element);
3568          case 1345445729: /*listMode*/  return new Property("listMode", "code", "How to handle the list mode for this element.", 0, 1, listMode);
3569          case -1249586564: /*variable*/  return new Property("variable", "id", "Named context for field, if a field is specified.", 0, 1, variable);
3570          case -861311717: /*condition*/  return new Property("condition", "string", "FHIRPath expression  - must be true or the rule does not apply.", 0, 1, condition);
3571          case 94627080: /*check*/  return new Property("check", "string", "FHIRPath expression  - must be true or the mapping engine throws an error instead of completing.", 0, 1, check);
3572          case -1067155421: /*logMessage*/  return new Property("logMessage", "string", "A FHIRPath expression which specifies a message to put in the transform log when content matching the source rule is found.", 0, 1, logMessage);
3573          default: return super.getNamedProperty(_hash, _name, _checkValid);
3574          }
3575
3576        }
3577
3578      @Override
3579      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3580        switch (hash) {
3581        case 951530927: /*context*/ return this.context == null ? new Base[0] : new Base[] {this.context}; // IdType
3582        case 108114: /*min*/ return this.min == null ? new Base[0] : new Base[] {this.min}; // IntegerType
3583        case 107876: /*max*/ return this.max == null ? new Base[0] : new Base[] {this.max}; // StringType
3584        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // StringType
3585        case -659125328: /*defaultValue*/ return this.defaultValue == null ? new Base[0] : new Base[] {this.defaultValue}; // StringType
3586        case -1662836996: /*element*/ return this.element == null ? new Base[0] : new Base[] {this.element}; // StringType
3587        case 1345445729: /*listMode*/ return this.listMode == null ? new Base[0] : new Base[] {this.listMode}; // Enumeration<StructureMapSourceListMode>
3588        case -1249586564: /*variable*/ return this.variable == null ? new Base[0] : new Base[] {this.variable}; // IdType
3589        case -861311717: /*condition*/ return this.condition == null ? new Base[0] : new Base[] {this.condition}; // StringType
3590        case 94627080: /*check*/ return this.check == null ? new Base[0] : new Base[] {this.check}; // StringType
3591        case -1067155421: /*logMessage*/ return this.logMessage == null ? new Base[0] : new Base[] {this.logMessage}; // StringType
3592        default: return super.getProperty(hash, name, checkValid);
3593        }
3594
3595      }
3596
3597      @Override
3598      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3599        switch (hash) {
3600        case 951530927: // context
3601          this.context = TypeConvertor.castToId(value); // IdType
3602          return value;
3603        case 108114: // min
3604          this.min = TypeConvertor.castToInteger(value); // IntegerType
3605          return value;
3606        case 107876: // max
3607          this.max = TypeConvertor.castToString(value); // StringType
3608          return value;
3609        case 3575610: // type
3610          this.type = TypeConvertor.castToString(value); // StringType
3611          return value;
3612        case -659125328: // defaultValue
3613          this.defaultValue = TypeConvertor.castToString(value); // StringType
3614          return value;
3615        case -1662836996: // element
3616          this.element = TypeConvertor.castToString(value); // StringType
3617          return value;
3618        case 1345445729: // listMode
3619          value = new StructureMapSourceListModeEnumFactory().fromType(TypeConvertor.castToCode(value));
3620          this.listMode = (Enumeration) value; // Enumeration<StructureMapSourceListMode>
3621          return value;
3622        case -1249586564: // variable
3623          this.variable = TypeConvertor.castToId(value); // IdType
3624          return value;
3625        case -861311717: // condition
3626          this.condition = TypeConvertor.castToString(value); // StringType
3627          return value;
3628        case 94627080: // check
3629          this.check = TypeConvertor.castToString(value); // StringType
3630          return value;
3631        case -1067155421: // logMessage
3632          this.logMessage = TypeConvertor.castToString(value); // StringType
3633          return value;
3634        default: return super.setProperty(hash, name, value);
3635        }
3636
3637      }
3638
3639      @Override
3640      public Base setProperty(String name, Base value) throws FHIRException {
3641        if (name.equals("context")) {
3642          this.context = TypeConvertor.castToId(value); // IdType
3643        } else if (name.equals("min")) {
3644          this.min = TypeConvertor.castToInteger(value); // IntegerType
3645        } else if (name.equals("max")) {
3646          this.max = TypeConvertor.castToString(value); // StringType
3647        } else if (name.equals("type")) {
3648          this.type = TypeConvertor.castToString(value); // StringType
3649        } else if (name.equals("defaultValue")) {
3650          this.defaultValue = TypeConvertor.castToString(value); // StringType
3651        } else if (name.equals("element")) {
3652          this.element = TypeConvertor.castToString(value); // StringType
3653        } else if (name.equals("listMode")) {
3654          value = new StructureMapSourceListModeEnumFactory().fromType(TypeConvertor.castToCode(value));
3655          this.listMode = (Enumeration) value; // Enumeration<StructureMapSourceListMode>
3656        } else if (name.equals("variable")) {
3657          this.variable = TypeConvertor.castToId(value); // IdType
3658        } else if (name.equals("condition")) {
3659          this.condition = TypeConvertor.castToString(value); // StringType
3660        } else if (name.equals("check")) {
3661          this.check = TypeConvertor.castToString(value); // StringType
3662        } else if (name.equals("logMessage")) {
3663          this.logMessage = TypeConvertor.castToString(value); // StringType
3664        } else
3665          return super.setProperty(name, value);
3666        return value;
3667      }
3668
3669      @Override
3670      public Base makeProperty(int hash, String name) throws FHIRException {
3671        switch (hash) {
3672        case 951530927:  return getContextElement();
3673        case 108114:  return getMinElement();
3674        case 107876:  return getMaxElement();
3675        case 3575610:  return getTypeElement();
3676        case -659125328:  return getDefaultValueElement();
3677        case -1662836996:  return getElementElement();
3678        case 1345445729:  return getListModeElement();
3679        case -1249586564:  return getVariableElement();
3680        case -861311717:  return getConditionElement();
3681        case 94627080:  return getCheckElement();
3682        case -1067155421:  return getLogMessageElement();
3683        default: return super.makeProperty(hash, name);
3684        }
3685
3686      }
3687
3688      @Override
3689      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3690        switch (hash) {
3691        case 951530927: /*context*/ return new String[] {"id"};
3692        case 108114: /*min*/ return new String[] {"integer"};
3693        case 107876: /*max*/ return new String[] {"string"};
3694        case 3575610: /*type*/ return new String[] {"string"};
3695        case -659125328: /*defaultValue*/ return new String[] {"string"};
3696        case -1662836996: /*element*/ return new String[] {"string"};
3697        case 1345445729: /*listMode*/ return new String[] {"code"};
3698        case -1249586564: /*variable*/ return new String[] {"id"};
3699        case -861311717: /*condition*/ return new String[] {"string"};
3700        case 94627080: /*check*/ return new String[] {"string"};
3701        case -1067155421: /*logMessage*/ return new String[] {"string"};
3702        default: return super.getTypesForProperty(hash, name);
3703        }
3704
3705      }
3706
3707      @Override
3708      public Base addChild(String name) throws FHIRException {
3709        if (name.equals("context")) {
3710          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.context");
3711        }
3712        else if (name.equals("min")) {
3713          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.min");
3714        }
3715        else if (name.equals("max")) {
3716          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.max");
3717        }
3718        else if (name.equals("type")) {
3719          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.type");
3720        }
3721        else if (name.equals("defaultValue")) {
3722          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.defaultValue");
3723        }
3724        else if (name.equals("element")) {
3725          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.element");
3726        }
3727        else if (name.equals("listMode")) {
3728          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.listMode");
3729        }
3730        else if (name.equals("variable")) {
3731          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.variable");
3732        }
3733        else if (name.equals("condition")) {
3734          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.condition");
3735        }
3736        else if (name.equals("check")) {
3737          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.check");
3738        }
3739        else if (name.equals("logMessage")) {
3740          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.source.logMessage");
3741        }
3742        else
3743          return super.addChild(name);
3744      }
3745
3746      public StructureMapGroupRuleSourceComponent copy() {
3747        StructureMapGroupRuleSourceComponent dst = new StructureMapGroupRuleSourceComponent();
3748        copyValues(dst);
3749        return dst;
3750      }
3751
3752      public void copyValues(StructureMapGroupRuleSourceComponent dst) {
3753        super.copyValues(dst);
3754        dst.context = context == null ? null : context.copy();
3755        dst.min = min == null ? null : min.copy();
3756        dst.max = max == null ? null : max.copy();
3757        dst.type = type == null ? null : type.copy();
3758        dst.defaultValue = defaultValue == null ? null : defaultValue.copy();
3759        dst.element = element == null ? null : element.copy();
3760        dst.listMode = listMode == null ? null : listMode.copy();
3761        dst.variable = variable == null ? null : variable.copy();
3762        dst.condition = condition == null ? null : condition.copy();
3763        dst.check = check == null ? null : check.copy();
3764        dst.logMessage = logMessage == null ? null : logMessage.copy();
3765      }
3766
3767      @Override
3768      public boolean equalsDeep(Base other_) {
3769        if (!super.equalsDeep(other_))
3770          return false;
3771        if (!(other_ instanceof StructureMapGroupRuleSourceComponent))
3772          return false;
3773        StructureMapGroupRuleSourceComponent o = (StructureMapGroupRuleSourceComponent) other_;
3774        return compareDeep(context, o.context, true) && compareDeep(min, o.min, true) && compareDeep(max, o.max, true)
3775           && compareDeep(type, o.type, true) && compareDeep(defaultValue, o.defaultValue, true) && compareDeep(element, o.element, true)
3776           && compareDeep(listMode, o.listMode, true) && compareDeep(variable, o.variable, true) && compareDeep(condition, o.condition, true)
3777           && compareDeep(check, o.check, true) && compareDeep(logMessage, o.logMessage, true);
3778      }
3779
3780      @Override
3781      public boolean equalsShallow(Base other_) {
3782        if (!super.equalsShallow(other_))
3783          return false;
3784        if (!(other_ instanceof StructureMapGroupRuleSourceComponent))
3785          return false;
3786        StructureMapGroupRuleSourceComponent o = (StructureMapGroupRuleSourceComponent) other_;
3787        return compareValues(context, o.context, true) && compareValues(min, o.min, true) && compareValues(max, o.max, true)
3788           && compareValues(type, o.type, true) && compareValues(defaultValue, o.defaultValue, true) && compareValues(element, o.element, true)
3789           && compareValues(listMode, o.listMode, true) && compareValues(variable, o.variable, true) && compareValues(condition, o.condition, true)
3790           && compareValues(check, o.check, true) && compareValues(logMessage, o.logMessage, true);
3791      }
3792
3793      public boolean isEmpty() {
3794        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(context, min, max, type
3795          , defaultValue, element, listMode, variable, condition, check, logMessage);
3796      }
3797
3798  public String fhirType() {
3799    return "StructureMap.group.rule.source";
3800
3801  }
3802
3803// added from java-adornments.txt:
3804public String toString() {
3805    return StructureMapUtilities.sourceToString(this);
3806  }
3807// end addition
3808  }
3809
3810    @Block()
3811    public static class StructureMapGroupRuleTargetComponent extends BackboneElement implements IBaseBackboneElement {
3812        /**
3813         * Variable this rule applies to.
3814         */
3815        @Child(name = "context", type = {IdType.class}, order=1, min=0, max=1, modifier=false, summary=true)
3816        @Description(shortDefinition="Variable this rule applies to", formalDefinition="Variable this rule applies to." )
3817        protected IdType context;
3818
3819        /**
3820         * Field to create in the context.
3821         */
3822        @Child(name = "element", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
3823        @Description(shortDefinition="Field to create in the context", formalDefinition="Field to create in the context." )
3824        protected StringType element;
3825
3826        /**
3827         * Named context for field, if desired, and a field is specified.
3828         */
3829        @Child(name = "variable", type = {IdType.class}, order=3, min=0, max=1, modifier=false, summary=true)
3830        @Description(shortDefinition="Named context for field, if desired, and a field is specified", formalDefinition="Named context for field, if desired, and a field is specified." )
3831        protected IdType variable;
3832
3833        /**
3834         * If field is a list, how to manage the list.
3835         */
3836        @Child(name = "listMode", type = {CodeType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3837        @Description(shortDefinition="first | share | last | collate", formalDefinition="If field is a list, how to manage the list." )
3838        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/map-target-list-mode")
3839        protected List<Enumeration<StructureMapTargetListMode>> listMode;
3840
3841        /**
3842         * Internal rule reference for shared list items.
3843         */
3844        @Child(name = "listRuleId", type = {IdType.class}, order=5, min=0, max=1, modifier=false, summary=true)
3845        @Description(shortDefinition="Internal rule reference for shared list items", formalDefinition="Internal rule reference for shared list items." )
3846        protected IdType listRuleId;
3847
3848        /**
3849         * How the data is copied / created.
3850         */
3851        @Child(name = "transform", type = {CodeType.class}, order=6, min=0, max=1, modifier=false, summary=true)
3852        @Description(shortDefinition="create | copy +", formalDefinition="How the data is copied / created." )
3853        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/map-transform")
3854        protected Enumeration<StructureMapTransform> transform;
3855
3856        /**
3857         * Parameters to the transform.
3858         */
3859        @Child(name = "parameter", type = {}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3860        @Description(shortDefinition="Parameters to the transform", formalDefinition="Parameters to the transform." )
3861        protected List<StructureMapGroupRuleTargetParameterComponent> parameter;
3862
3863        private static final long serialVersionUID = 1225668521L;
3864
3865    /**
3866     * Constructor
3867     */
3868      public StructureMapGroupRuleTargetComponent() {
3869        super();
3870      }
3871
3872        /**
3873         * @return {@link #context} (Variable this rule applies to.). This is the underlying object with id, value and extensions. The accessor "getContext" gives direct access to the value
3874         */
3875        public IdType getContextElement() { 
3876          if (this.context == null)
3877            if (Configuration.errorOnAutoCreate())
3878              throw new Error("Attempt to auto-create StructureMapGroupRuleTargetComponent.context");
3879            else if (Configuration.doAutoCreate())
3880              this.context = new IdType(); // bb
3881          return this.context;
3882        }
3883
3884        public boolean hasContextElement() { 
3885          return this.context != null && !this.context.isEmpty();
3886        }
3887
3888        public boolean hasContext() { 
3889          return this.context != null && !this.context.isEmpty();
3890        }
3891
3892        /**
3893         * @param value {@link #context} (Variable this rule applies to.). This is the underlying object with id, value and extensions. The accessor "getContext" gives direct access to the value
3894         */
3895        public StructureMapGroupRuleTargetComponent setContextElement(IdType value) { 
3896          this.context = value;
3897          return this;
3898        }
3899
3900        /**
3901         * @return Variable this rule applies to.
3902         */
3903        public String getContext() { 
3904          return this.context == null ? null : this.context.getValue();
3905        }
3906
3907        /**
3908         * @param value Variable this rule applies to.
3909         */
3910        public StructureMapGroupRuleTargetComponent setContext(String value) { 
3911          if (Utilities.noString(value))
3912            this.context = null;
3913          else {
3914            if (this.context == null)
3915              this.context = new IdType();
3916            this.context.setValue(value);
3917          }
3918          return this;
3919        }
3920
3921        /**
3922         * @return {@link #element} (Field to create in the context.). This is the underlying object with id, value and extensions. The accessor "getElement" gives direct access to the value
3923         */
3924        public StringType getElementElement() { 
3925          if (this.element == null)
3926            if (Configuration.errorOnAutoCreate())
3927              throw new Error("Attempt to auto-create StructureMapGroupRuleTargetComponent.element");
3928            else if (Configuration.doAutoCreate())
3929              this.element = new StringType(); // bb
3930          return this.element;
3931        }
3932
3933        public boolean hasElementElement() { 
3934          return this.element != null && !this.element.isEmpty();
3935        }
3936
3937        public boolean hasElement() { 
3938          return this.element != null && !this.element.isEmpty();
3939        }
3940
3941        /**
3942         * @param value {@link #element} (Field to create in the context.). This is the underlying object with id, value and extensions. The accessor "getElement" gives direct access to the value
3943         */
3944        public StructureMapGroupRuleTargetComponent setElementElement(StringType value) { 
3945          this.element = value;
3946          return this;
3947        }
3948
3949        /**
3950         * @return Field to create in the context.
3951         */
3952        public String getElement() { 
3953          return this.element == null ? null : this.element.getValue();
3954        }
3955
3956        /**
3957         * @param value Field to create in the context.
3958         */
3959        public StructureMapGroupRuleTargetComponent setElement(String value) { 
3960          if (Utilities.noString(value))
3961            this.element = null;
3962          else {
3963            if (this.element == null)
3964              this.element = new StringType();
3965            this.element.setValue(value);
3966          }
3967          return this;
3968        }
3969
3970        /**
3971         * @return {@link #variable} (Named context for field, if desired, and a field is specified.). This is the underlying object with id, value and extensions. The accessor "getVariable" gives direct access to the value
3972         */
3973        public IdType getVariableElement() { 
3974          if (this.variable == null)
3975            if (Configuration.errorOnAutoCreate())
3976              throw new Error("Attempt to auto-create StructureMapGroupRuleTargetComponent.variable");
3977            else if (Configuration.doAutoCreate())
3978              this.variable = new IdType(); // bb
3979          return this.variable;
3980        }
3981
3982        public boolean hasVariableElement() { 
3983          return this.variable != null && !this.variable.isEmpty();
3984        }
3985
3986        public boolean hasVariable() { 
3987          return this.variable != null && !this.variable.isEmpty();
3988        }
3989
3990        /**
3991         * @param value {@link #variable} (Named context for field, if desired, and a field is specified.). This is the underlying object with id, value and extensions. The accessor "getVariable" gives direct access to the value
3992         */
3993        public StructureMapGroupRuleTargetComponent setVariableElement(IdType value) { 
3994          this.variable = value;
3995          return this;
3996        }
3997
3998        /**
3999         * @return Named context for field, if desired, and a field is specified.
4000         */
4001        public String getVariable() { 
4002          return this.variable == null ? null : this.variable.getValue();
4003        }
4004
4005        /**
4006         * @param value Named context for field, if desired, and a field is specified.
4007         */
4008        public StructureMapGroupRuleTargetComponent setVariable(String value) { 
4009          if (Utilities.noString(value))
4010            this.variable = null;
4011          else {
4012            if (this.variable == null)
4013              this.variable = new IdType();
4014            this.variable.setValue(value);
4015          }
4016          return this;
4017        }
4018
4019        /**
4020         * @return {@link #listMode} (If field is a list, how to manage the list.)
4021         */
4022        public List<Enumeration<StructureMapTargetListMode>> getListMode() { 
4023          if (this.listMode == null)
4024            this.listMode = new ArrayList<Enumeration<StructureMapTargetListMode>>();
4025          return this.listMode;
4026        }
4027
4028        /**
4029         * @return Returns a reference to <code>this</code> for easy method chaining
4030         */
4031        public StructureMapGroupRuleTargetComponent setListMode(List<Enumeration<StructureMapTargetListMode>> theListMode) { 
4032          this.listMode = theListMode;
4033          return this;
4034        }
4035
4036        public boolean hasListMode() { 
4037          if (this.listMode == null)
4038            return false;
4039          for (Enumeration<StructureMapTargetListMode> item : this.listMode)
4040            if (!item.isEmpty())
4041              return true;
4042          return false;
4043        }
4044
4045        /**
4046         * @return {@link #listMode} (If field is a list, how to manage the list.)
4047         */
4048        public Enumeration<StructureMapTargetListMode> addListModeElement() {//2 
4049          Enumeration<StructureMapTargetListMode> t = new Enumeration<StructureMapTargetListMode>(new StructureMapTargetListModeEnumFactory());
4050          if (this.listMode == null)
4051            this.listMode = new ArrayList<Enumeration<StructureMapTargetListMode>>();
4052          this.listMode.add(t);
4053          return t;
4054        }
4055
4056        /**
4057         * @param value {@link #listMode} (If field is a list, how to manage the list.)
4058         */
4059        public StructureMapGroupRuleTargetComponent addListMode(StructureMapTargetListMode value) { //1
4060          Enumeration<StructureMapTargetListMode> t = new Enumeration<StructureMapTargetListMode>(new StructureMapTargetListModeEnumFactory());
4061          t.setValue(value);
4062          if (this.listMode == null)
4063            this.listMode = new ArrayList<Enumeration<StructureMapTargetListMode>>();
4064          this.listMode.add(t);
4065          return this;
4066        }
4067
4068        /**
4069         * @param value {@link #listMode} (If field is a list, how to manage the list.)
4070         */
4071        public boolean hasListMode(StructureMapTargetListMode value) { 
4072          if (this.listMode == null)
4073            return false;
4074          for (Enumeration<StructureMapTargetListMode> v : this.listMode)
4075            if (v.getValue().equals(value)) // code
4076              return true;
4077          return false;
4078        }
4079
4080        /**
4081         * @return {@link #listRuleId} (Internal rule reference for shared list items.). This is the underlying object with id, value and extensions. The accessor "getListRuleId" gives direct access to the value
4082         */
4083        public IdType getListRuleIdElement() { 
4084          if (this.listRuleId == null)
4085            if (Configuration.errorOnAutoCreate())
4086              throw new Error("Attempt to auto-create StructureMapGroupRuleTargetComponent.listRuleId");
4087            else if (Configuration.doAutoCreate())
4088              this.listRuleId = new IdType(); // bb
4089          return this.listRuleId;
4090        }
4091
4092        public boolean hasListRuleIdElement() { 
4093          return this.listRuleId != null && !this.listRuleId.isEmpty();
4094        }
4095
4096        public boolean hasListRuleId() { 
4097          return this.listRuleId != null && !this.listRuleId.isEmpty();
4098        }
4099
4100        /**
4101         * @param value {@link #listRuleId} (Internal rule reference for shared list items.). This is the underlying object with id, value and extensions. The accessor "getListRuleId" gives direct access to the value
4102         */
4103        public StructureMapGroupRuleTargetComponent setListRuleIdElement(IdType value) { 
4104          this.listRuleId = value;
4105          return this;
4106        }
4107
4108        /**
4109         * @return Internal rule reference for shared list items.
4110         */
4111        public String getListRuleId() { 
4112          return this.listRuleId == null ? null : this.listRuleId.getValue();
4113        }
4114
4115        /**
4116         * @param value Internal rule reference for shared list items.
4117         */
4118        public StructureMapGroupRuleTargetComponent setListRuleId(String value) { 
4119          if (Utilities.noString(value))
4120            this.listRuleId = null;
4121          else {
4122            if (this.listRuleId == null)
4123              this.listRuleId = new IdType();
4124            this.listRuleId.setValue(value);
4125          }
4126          return this;
4127        }
4128
4129        /**
4130         * @return {@link #transform} (How the data is copied / created.). This is the underlying object with id, value and extensions. The accessor "getTransform" gives direct access to the value
4131         */
4132        public Enumeration<StructureMapTransform> getTransformElement() { 
4133          if (this.transform == null)
4134            if (Configuration.errorOnAutoCreate())
4135              throw new Error("Attempt to auto-create StructureMapGroupRuleTargetComponent.transform");
4136            else if (Configuration.doAutoCreate())
4137              this.transform = new Enumeration<StructureMapTransform>(new StructureMapTransformEnumFactory()); // bb
4138          return this.transform;
4139        }
4140
4141        public boolean hasTransformElement() { 
4142          return this.transform != null && !this.transform.isEmpty();
4143        }
4144
4145        public boolean hasTransform() { 
4146          return this.transform != null && !this.transform.isEmpty();
4147        }
4148
4149        /**
4150         * @param value {@link #transform} (How the data is copied / created.). This is the underlying object with id, value and extensions. The accessor "getTransform" gives direct access to the value
4151         */
4152        public StructureMapGroupRuleTargetComponent setTransformElement(Enumeration<StructureMapTransform> value) { 
4153          this.transform = value;
4154          return this;
4155        }
4156
4157        /**
4158         * @return How the data is copied / created.
4159         */
4160        public StructureMapTransform getTransform() { 
4161          return this.transform == null ? null : this.transform.getValue();
4162        }
4163
4164        /**
4165         * @param value How the data is copied / created.
4166         */
4167        public StructureMapGroupRuleTargetComponent setTransform(StructureMapTransform value) { 
4168          if (value == null)
4169            this.transform = null;
4170          else {
4171            if (this.transform == null)
4172              this.transform = new Enumeration<StructureMapTransform>(new StructureMapTransformEnumFactory());
4173            this.transform.setValue(value);
4174          }
4175          return this;
4176        }
4177
4178        /**
4179         * @return {@link #parameter} (Parameters to the transform.)
4180         */
4181        public List<StructureMapGroupRuleTargetParameterComponent> getParameter() { 
4182          if (this.parameter == null)
4183            this.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4184          return this.parameter;
4185        }
4186
4187        /**
4188         * @return Returns a reference to <code>this</code> for easy method chaining
4189         */
4190        public StructureMapGroupRuleTargetComponent setParameter(List<StructureMapGroupRuleTargetParameterComponent> theParameter) { 
4191          this.parameter = theParameter;
4192          return this;
4193        }
4194
4195        public boolean hasParameter() { 
4196          if (this.parameter == null)
4197            return false;
4198          for (StructureMapGroupRuleTargetParameterComponent item : this.parameter)
4199            if (!item.isEmpty())
4200              return true;
4201          return false;
4202        }
4203
4204        public StructureMapGroupRuleTargetParameterComponent addParameter() { //3
4205          StructureMapGroupRuleTargetParameterComponent t = new StructureMapGroupRuleTargetParameterComponent();
4206          if (this.parameter == null)
4207            this.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4208          this.parameter.add(t);
4209          return t;
4210        }
4211
4212        public StructureMapGroupRuleTargetComponent addParameter(StructureMapGroupRuleTargetParameterComponent t) { //3
4213          if (t == null)
4214            return this;
4215          if (this.parameter == null)
4216            this.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4217          this.parameter.add(t);
4218          return this;
4219        }
4220
4221        /**
4222         * @return The first repetition of repeating field {@link #parameter}, creating it if it does not already exist {3}
4223         */
4224        public StructureMapGroupRuleTargetParameterComponent getParameterFirstRep() { 
4225          if (getParameter().isEmpty()) {
4226            addParameter();
4227          }
4228          return getParameter().get(0);
4229        }
4230
4231        protected void listChildren(List<Property> children) {
4232          super.listChildren(children);
4233          children.add(new Property("context", "id", "Variable this rule applies to.", 0, 1, context));
4234          children.add(new Property("element", "string", "Field to create in the context.", 0, 1, element));
4235          children.add(new Property("variable", "id", "Named context for field, if desired, and a field is specified.", 0, 1, variable));
4236          children.add(new Property("listMode", "code", "If field is a list, how to manage the list.", 0, java.lang.Integer.MAX_VALUE, listMode));
4237          children.add(new Property("listRuleId", "id", "Internal rule reference for shared list items.", 0, 1, listRuleId));
4238          children.add(new Property("transform", "code", "How the data is copied / created.", 0, 1, transform));
4239          children.add(new Property("parameter", "", "Parameters to the transform.", 0, java.lang.Integer.MAX_VALUE, parameter));
4240        }
4241
4242        @Override
4243        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4244          switch (_hash) {
4245          case 951530927: /*context*/  return new Property("context", "id", "Variable this rule applies to.", 0, 1, context);
4246          case -1662836996: /*element*/  return new Property("element", "string", "Field to create in the context.", 0, 1, element);
4247          case -1249586564: /*variable*/  return new Property("variable", "id", "Named context for field, if desired, and a field is specified.", 0, 1, variable);
4248          case 1345445729: /*listMode*/  return new Property("listMode", "code", "If field is a list, how to manage the list.", 0, java.lang.Integer.MAX_VALUE, listMode);
4249          case 337117045: /*listRuleId*/  return new Property("listRuleId", "id", "Internal rule reference for shared list items.", 0, 1, listRuleId);
4250          case 1052666732: /*transform*/  return new Property("transform", "code", "How the data is copied / created.", 0, 1, transform);
4251          case 1954460585: /*parameter*/  return new Property("parameter", "", "Parameters to the transform.", 0, java.lang.Integer.MAX_VALUE, parameter);
4252          default: return super.getNamedProperty(_hash, _name, _checkValid);
4253          }
4254
4255        }
4256
4257      @Override
4258      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4259        switch (hash) {
4260        case 951530927: /*context*/ return this.context == null ? new Base[0] : new Base[] {this.context}; // IdType
4261        case -1662836996: /*element*/ return this.element == null ? new Base[0] : new Base[] {this.element}; // StringType
4262        case -1249586564: /*variable*/ return this.variable == null ? new Base[0] : new Base[] {this.variable}; // IdType
4263        case 1345445729: /*listMode*/ return this.listMode == null ? new Base[0] : this.listMode.toArray(new Base[this.listMode.size()]); // Enumeration<StructureMapTargetListMode>
4264        case 337117045: /*listRuleId*/ return this.listRuleId == null ? new Base[0] : new Base[] {this.listRuleId}; // IdType
4265        case 1052666732: /*transform*/ return this.transform == null ? new Base[0] : new Base[] {this.transform}; // Enumeration<StructureMapTransform>
4266        case 1954460585: /*parameter*/ return this.parameter == null ? new Base[0] : this.parameter.toArray(new Base[this.parameter.size()]); // StructureMapGroupRuleTargetParameterComponent
4267        default: return super.getProperty(hash, name, checkValid);
4268        }
4269
4270      }
4271
4272      @Override
4273      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4274        switch (hash) {
4275        case 951530927: // context
4276          this.context = TypeConvertor.castToId(value); // IdType
4277          return value;
4278        case -1662836996: // element
4279          this.element = TypeConvertor.castToString(value); // StringType
4280          return value;
4281        case -1249586564: // variable
4282          this.variable = TypeConvertor.castToId(value); // IdType
4283          return value;
4284        case 1345445729: // listMode
4285          value = new StructureMapTargetListModeEnumFactory().fromType(TypeConvertor.castToCode(value));
4286          this.getListMode().add((Enumeration) value); // Enumeration<StructureMapTargetListMode>
4287          return value;
4288        case 337117045: // listRuleId
4289          this.listRuleId = TypeConvertor.castToId(value); // IdType
4290          return value;
4291        case 1052666732: // transform
4292          value = new StructureMapTransformEnumFactory().fromType(TypeConvertor.castToCode(value));
4293          this.transform = (Enumeration) value; // Enumeration<StructureMapTransform>
4294          return value;
4295        case 1954460585: // parameter
4296          this.getParameter().add((StructureMapGroupRuleTargetParameterComponent) value); // StructureMapGroupRuleTargetParameterComponent
4297          return value;
4298        default: return super.setProperty(hash, name, value);
4299        }
4300
4301      }
4302
4303      @Override
4304      public Base setProperty(String name, Base value) throws FHIRException {
4305        if (name.equals("context")) {
4306          this.context = TypeConvertor.castToId(value); // IdType
4307        } else if (name.equals("element")) {
4308          this.element = TypeConvertor.castToString(value); // StringType
4309        } else if (name.equals("variable")) {
4310          this.variable = TypeConvertor.castToId(value); // IdType
4311        } else if (name.equals("listMode")) {
4312          value = new StructureMapTargetListModeEnumFactory().fromType(TypeConvertor.castToCode(value));
4313          this.getListMode().add((Enumeration) value);
4314        } else if (name.equals("listRuleId")) {
4315          this.listRuleId = TypeConvertor.castToId(value); // IdType
4316        } else if (name.equals("transform")) {
4317          value = new StructureMapTransformEnumFactory().fromType(TypeConvertor.castToCode(value));
4318          this.transform = (Enumeration) value; // Enumeration<StructureMapTransform>
4319        } else if (name.equals("parameter")) {
4320          this.getParameter().add((StructureMapGroupRuleTargetParameterComponent) value);
4321        } else
4322          return super.setProperty(name, value);
4323        return value;
4324      }
4325
4326      @Override
4327      public Base makeProperty(int hash, String name) throws FHIRException {
4328        switch (hash) {
4329        case 951530927:  return getContextElement();
4330        case -1662836996:  return getElementElement();
4331        case -1249586564:  return getVariableElement();
4332        case 1345445729:  return addListModeElement();
4333        case 337117045:  return getListRuleIdElement();
4334        case 1052666732:  return getTransformElement();
4335        case 1954460585:  return addParameter(); 
4336        default: return super.makeProperty(hash, name);
4337        }
4338
4339      }
4340
4341      @Override
4342      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4343        switch (hash) {
4344        case 951530927: /*context*/ return new String[] {"id"};
4345        case -1662836996: /*element*/ return new String[] {"string"};
4346        case -1249586564: /*variable*/ return new String[] {"id"};
4347        case 1345445729: /*listMode*/ return new String[] {"code"};
4348        case 337117045: /*listRuleId*/ return new String[] {"id"};
4349        case 1052666732: /*transform*/ return new String[] {"code"};
4350        case 1954460585: /*parameter*/ return new String[] {};
4351        default: return super.getTypesForProperty(hash, name);
4352        }
4353
4354      }
4355
4356      @Override
4357      public Base addChild(String name) throws FHIRException {
4358        if (name.equals("context")) {
4359          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.target.context");
4360        }
4361        else if (name.equals("element")) {
4362          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.target.element");
4363        }
4364        else if (name.equals("variable")) {
4365          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.target.variable");
4366        }
4367        else if (name.equals("listMode")) {
4368          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.target.listMode");
4369        }
4370        else if (name.equals("listRuleId")) {
4371          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.target.listRuleId");
4372        }
4373        else if (name.equals("transform")) {
4374          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.target.transform");
4375        }
4376        else if (name.equals("parameter")) {
4377          return addParameter();
4378        }
4379        else
4380          return super.addChild(name);
4381      }
4382
4383      public StructureMapGroupRuleTargetComponent copy() {
4384        StructureMapGroupRuleTargetComponent dst = new StructureMapGroupRuleTargetComponent();
4385        copyValues(dst);
4386        return dst;
4387      }
4388
4389      public void copyValues(StructureMapGroupRuleTargetComponent dst) {
4390        super.copyValues(dst);
4391        dst.context = context == null ? null : context.copy();
4392        dst.element = element == null ? null : element.copy();
4393        dst.variable = variable == null ? null : variable.copy();
4394        if (listMode != null) {
4395          dst.listMode = new ArrayList<Enumeration<StructureMapTargetListMode>>();
4396          for (Enumeration<StructureMapTargetListMode> i : listMode)
4397            dst.listMode.add(i.copy());
4398        };
4399        dst.listRuleId = listRuleId == null ? null : listRuleId.copy();
4400        dst.transform = transform == null ? null : transform.copy();
4401        if (parameter != null) {
4402          dst.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4403          for (StructureMapGroupRuleTargetParameterComponent i : parameter)
4404            dst.parameter.add(i.copy());
4405        };
4406      }
4407
4408      @Override
4409      public boolean equalsDeep(Base other_) {
4410        if (!super.equalsDeep(other_))
4411          return false;
4412        if (!(other_ instanceof StructureMapGroupRuleTargetComponent))
4413          return false;
4414        StructureMapGroupRuleTargetComponent o = (StructureMapGroupRuleTargetComponent) other_;
4415        return compareDeep(context, o.context, true) && compareDeep(element, o.element, true) && compareDeep(variable, o.variable, true)
4416           && compareDeep(listMode, o.listMode, true) && compareDeep(listRuleId, o.listRuleId, true) && compareDeep(transform, o.transform, true)
4417           && compareDeep(parameter, o.parameter, true);
4418      }
4419
4420      @Override
4421      public boolean equalsShallow(Base other_) {
4422        if (!super.equalsShallow(other_))
4423          return false;
4424        if (!(other_ instanceof StructureMapGroupRuleTargetComponent))
4425          return false;
4426        StructureMapGroupRuleTargetComponent o = (StructureMapGroupRuleTargetComponent) other_;
4427        return compareValues(context, o.context, true) && compareValues(element, o.element, true) && compareValues(variable, o.variable, true)
4428           && compareValues(listMode, o.listMode, true) && compareValues(listRuleId, o.listRuleId, true) && compareValues(transform, o.transform, true)
4429          ;
4430      }
4431
4432      public boolean isEmpty() {
4433        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(context, element, variable
4434          , listMode, listRuleId, transform, parameter);
4435      }
4436
4437  public String fhirType() {
4438    return "StructureMap.group.rule.target";
4439
4440  }
4441
4442// added from java-adornments.txt:
4443public String toString() {
4444    return StructureMapUtilities.targetToString(this);
4445  }
4446// end addition
4447  }
4448
4449    @Block()
4450    public static class StructureMapGroupRuleTargetParameterComponent extends BackboneElement implements IBaseBackboneElement {
4451        /**
4452         * Parameter value - variable or literal.
4453         */
4454        @Child(name = "value", type = {IdType.class, StringType.class, BooleanType.class, IntegerType.class, DecimalType.class, DateType.class, TimeType.class, DateTimeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
4455        @Description(shortDefinition="Parameter value - variable or literal", formalDefinition="Parameter value - variable or literal." )
4456        protected DataType value;
4457
4458        private static final long serialVersionUID = -1135414639L;
4459
4460    /**
4461     * Constructor
4462     */
4463      public StructureMapGroupRuleTargetParameterComponent() {
4464        super();
4465      }
4466
4467    /**
4468     * Constructor
4469     */
4470      public StructureMapGroupRuleTargetParameterComponent(DataType value) {
4471        super();
4472        this.setValue(value);
4473      }
4474
4475        /**
4476         * @return {@link #value} (Parameter value - variable or literal.)
4477         */
4478        public DataType getValue() { 
4479          return this.value;
4480        }
4481
4482        /**
4483         * @return {@link #value} (Parameter value - variable or literal.)
4484         */
4485        public IdType getValueIdType() throws FHIRException { 
4486          if (this.value == null)
4487            this.value = new IdType();
4488          if (!(this.value instanceof IdType))
4489            throw new FHIRException("Type mismatch: the type IdType was expected, but "+this.value.getClass().getName()+" was encountered");
4490          return (IdType) this.value;
4491        }
4492
4493        public boolean hasValueIdType() { 
4494          return this != null && this.value instanceof IdType;
4495        }
4496
4497        /**
4498         * @return {@link #value} (Parameter value - variable or literal.)
4499         */
4500        public StringType getValueStringType() throws FHIRException { 
4501          if (this.value == null)
4502            this.value = new StringType();
4503          if (!(this.value instanceof StringType))
4504            throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.value.getClass().getName()+" was encountered");
4505          return (StringType) this.value;
4506        }
4507
4508        public boolean hasValueStringType() { 
4509          return this != null && this.value instanceof StringType;
4510        }
4511
4512        /**
4513         * @return {@link #value} (Parameter value - variable or literal.)
4514         */
4515        public BooleanType getValueBooleanType() throws FHIRException { 
4516          if (this.value == null)
4517            this.value = new BooleanType();
4518          if (!(this.value instanceof BooleanType))
4519            throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.value.getClass().getName()+" was encountered");
4520          return (BooleanType) this.value;
4521        }
4522
4523        public boolean hasValueBooleanType() { 
4524          return this != null && this.value instanceof BooleanType;
4525        }
4526
4527        /**
4528         * @return {@link #value} (Parameter value - variable or literal.)
4529         */
4530        public IntegerType getValueIntegerType() throws FHIRException { 
4531          if (this.value == null)
4532            this.value = new IntegerType();
4533          if (!(this.value instanceof IntegerType))
4534            throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.value.getClass().getName()+" was encountered");
4535          return (IntegerType) this.value;
4536        }
4537
4538        public boolean hasValueIntegerType() { 
4539          return this != null && this.value instanceof IntegerType;
4540        }
4541
4542        /**
4543         * @return {@link #value} (Parameter value - variable or literal.)
4544         */
4545        public DecimalType getValueDecimalType() throws FHIRException { 
4546          if (this.value == null)
4547            this.value = new DecimalType();
4548          if (!(this.value instanceof DecimalType))
4549            throw new FHIRException("Type mismatch: the type DecimalType was expected, but "+this.value.getClass().getName()+" was encountered");
4550          return (DecimalType) this.value;
4551        }
4552
4553        public boolean hasValueDecimalType() { 
4554          return this != null && this.value instanceof DecimalType;
4555        }
4556
4557        /**
4558         * @return {@link #value} (Parameter value - variable or literal.)
4559         */
4560        public DateType getValueDateType() throws FHIRException { 
4561          if (this.value == null)
4562            this.value = new DateType();
4563          if (!(this.value instanceof DateType))
4564            throw new FHIRException("Type mismatch: the type DateType was expected, but "+this.value.getClass().getName()+" was encountered");
4565          return (DateType) this.value;
4566        }
4567
4568        public boolean hasValueDateType() { 
4569          return this != null && this.value instanceof DateType;
4570        }
4571
4572        /**
4573         * @return {@link #value} (Parameter value - variable or literal.)
4574         */
4575        public TimeType getValueTimeType() throws FHIRException { 
4576          if (this.value == null)
4577            this.value = new TimeType();
4578          if (!(this.value instanceof TimeType))
4579            throw new FHIRException("Type mismatch: the type TimeType was expected, but "+this.value.getClass().getName()+" was encountered");
4580          return (TimeType) this.value;
4581        }
4582
4583        public boolean hasValueTimeType() { 
4584          return this != null && this.value instanceof TimeType;
4585        }
4586
4587        /**
4588         * @return {@link #value} (Parameter value - variable or literal.)
4589         */
4590        public DateTimeType getValueDateTimeType() throws FHIRException { 
4591          if (this.value == null)
4592            this.value = new DateTimeType();
4593          if (!(this.value instanceof DateTimeType))
4594            throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.value.getClass().getName()+" was encountered");
4595          return (DateTimeType) this.value;
4596        }
4597
4598        public boolean hasValueDateTimeType() { 
4599          return this != null && this.value instanceof DateTimeType;
4600        }
4601
4602        public boolean hasValue() { 
4603          return this.value != null && !this.value.isEmpty();
4604        }
4605
4606        /**
4607         * @param value {@link #value} (Parameter value - variable or literal.)
4608         */
4609        public StructureMapGroupRuleTargetParameterComponent setValue(DataType value) { 
4610          if (value != null && !(value instanceof IdType || value instanceof StringType || value instanceof BooleanType || value instanceof IntegerType || value instanceof DecimalType || value instanceof DateType || value instanceof TimeType || value instanceof DateTimeType))
4611            throw new Error("Not the right type for StructureMap.group.rule.target.parameter.value[x]: "+value.fhirType());
4612          this.value = value;
4613          return this;
4614        }
4615
4616        protected void listChildren(List<Property> children) {
4617          super.listChildren(children);
4618          children.add(new Property("value[x]", "id|string|boolean|integer|decimal|date|time|dateTime", "Parameter value - variable or literal.", 0, 1, value));
4619        }
4620
4621        @Override
4622        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4623          switch (_hash) {
4624          case -1410166417: /*value[x]*/  return new Property("value[x]", "id|string|boolean|integer|decimal|date|time|dateTime", "Parameter value - variable or literal.", 0, 1, value);
4625          case 111972721: /*value*/  return new Property("value[x]", "id|string|boolean|integer|decimal|date|time|dateTime", "Parameter value - variable or literal.", 0, 1, value);
4626          case 231604844: /*valueId*/  return new Property("value[x]", "id", "Parameter value - variable or literal.", 0, 1, value);
4627          case -1424603934: /*valueString*/  return new Property("value[x]", "string", "Parameter value - variable or literal.", 0, 1, value);
4628          case 733421943: /*valueBoolean*/  return new Property("value[x]", "boolean", "Parameter value - variable or literal.", 0, 1, value);
4629          case -1668204915: /*valueInteger*/  return new Property("value[x]", "integer", "Parameter value - variable or literal.", 0, 1, value);
4630          case -2083993440: /*valueDecimal*/  return new Property("value[x]", "decimal", "Parameter value - variable or literal.", 0, 1, value);
4631          case -766192449: /*valueDate*/  return new Property("value[x]", "date", "Parameter value - variable or literal.", 0, 1, value);
4632          case -765708322: /*valueTime*/  return new Property("value[x]", "time", "Parameter value - variable or literal.", 0, 1, value);
4633          case 1047929900: /*valueDateTime*/  return new Property("value[x]", "dateTime", "Parameter value - variable or literal.", 0, 1, value);
4634          default: return super.getNamedProperty(_hash, _name, _checkValid);
4635          }
4636
4637        }
4638
4639      @Override
4640      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4641        switch (hash) {
4642        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // DataType
4643        default: return super.getProperty(hash, name, checkValid);
4644        }
4645
4646      }
4647
4648      @Override
4649      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4650        switch (hash) {
4651        case 111972721: // value
4652          this.value = TypeConvertor.castToType(value); // DataType
4653          return value;
4654        default: return super.setProperty(hash, name, value);
4655        }
4656
4657      }
4658
4659      @Override
4660      public Base setProperty(String name, Base value) throws FHIRException {
4661        if (name.equals("value[x]")) {
4662          this.value = TypeConvertor.castToType(value); // DataType
4663        } else
4664          return super.setProperty(name, value);
4665        return value;
4666      }
4667
4668      @Override
4669      public Base makeProperty(int hash, String name) throws FHIRException {
4670        switch (hash) {
4671        case -1410166417:  return getValue();
4672        case 111972721:  return getValue();
4673        default: return super.makeProperty(hash, name);
4674        }
4675
4676      }
4677
4678      @Override
4679      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4680        switch (hash) {
4681        case 111972721: /*value*/ return new String[] {"id", "string", "boolean", "integer", "decimal", "date", "time", "dateTime"};
4682        default: return super.getTypesForProperty(hash, name);
4683        }
4684
4685      }
4686
4687      @Override
4688      public Base addChild(String name) throws FHIRException {
4689        if (name.equals("valueId")) {
4690          this.value = new IdType();
4691          return this.value;
4692        }
4693        else if (name.equals("valueString")) {
4694          this.value = new StringType();
4695          return this.value;
4696        }
4697        else if (name.equals("valueBoolean")) {
4698          this.value = new BooleanType();
4699          return this.value;
4700        }
4701        else if (name.equals("valueInteger")) {
4702          this.value = new IntegerType();
4703          return this.value;
4704        }
4705        else if (name.equals("valueDecimal")) {
4706          this.value = new DecimalType();
4707          return this.value;
4708        }
4709        else if (name.equals("valueDate")) {
4710          this.value = new DateType();
4711          return this.value;
4712        }
4713        else if (name.equals("valueTime")) {
4714          this.value = new TimeType();
4715          return this.value;
4716        }
4717        else if (name.equals("valueDateTime")) {
4718          this.value = new DateTimeType();
4719          return this.value;
4720        }
4721        else
4722          return super.addChild(name);
4723      }
4724
4725      public StructureMapGroupRuleTargetParameterComponent copy() {
4726        StructureMapGroupRuleTargetParameterComponent dst = new StructureMapGroupRuleTargetParameterComponent();
4727        copyValues(dst);
4728        return dst;
4729      }
4730
4731      public void copyValues(StructureMapGroupRuleTargetParameterComponent dst) {
4732        super.copyValues(dst);
4733        dst.value = value == null ? null : value.copy();
4734      }
4735
4736      @Override
4737      public boolean equalsDeep(Base other_) {
4738        if (!super.equalsDeep(other_))
4739          return false;
4740        if (!(other_ instanceof StructureMapGroupRuleTargetParameterComponent))
4741          return false;
4742        StructureMapGroupRuleTargetParameterComponent o = (StructureMapGroupRuleTargetParameterComponent) other_;
4743        return compareDeep(value, o.value, true);
4744      }
4745
4746      @Override
4747      public boolean equalsShallow(Base other_) {
4748        if (!super.equalsShallow(other_))
4749          return false;
4750        if (!(other_ instanceof StructureMapGroupRuleTargetParameterComponent))
4751          return false;
4752        StructureMapGroupRuleTargetParameterComponent o = (StructureMapGroupRuleTargetParameterComponent) other_;
4753        return true;
4754      }
4755
4756      public boolean isEmpty() {
4757        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(value);
4758      }
4759
4760  public String fhirType() {
4761    return "StructureMap.group.rule.target.parameter";
4762
4763  }
4764
4765// added from java-adornments.txt:
4766public String toString() {
4767        return value == null ? "null!" : value.toString();
4768      }
4769// end addition
4770  }
4771
4772    @Block()
4773    public static class StructureMapGroupRuleDependentComponent extends BackboneElement implements IBaseBackboneElement {
4774        /**
4775         * Name of a rule or group to apply.
4776         */
4777        @Child(name = "name", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=true)
4778        @Description(shortDefinition="Name of a rule or group to apply", formalDefinition="Name of a rule or group to apply." )
4779        protected IdType name;
4780
4781        /**
4782         * Parameter to pass to the rule or group.
4783         */
4784        @Child(name = "parameter", type = {StructureMapGroupRuleTargetParameterComponent.class}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
4785        @Description(shortDefinition="Parameter to pass to the rule or group", formalDefinition="Parameter to pass to the rule or group." )
4786        protected List<StructureMapGroupRuleTargetParameterComponent> parameter;
4787
4788        private static final long serialVersionUID = -290346576L;
4789
4790    /**
4791     * Constructor
4792     */
4793      public StructureMapGroupRuleDependentComponent() {
4794        super();
4795      }
4796
4797    /**
4798     * Constructor
4799     */
4800      public StructureMapGroupRuleDependentComponent(String name, StructureMapGroupRuleTargetParameterComponent parameter) {
4801        super();
4802        this.setName(name);
4803        this.addParameter(parameter);
4804      }
4805
4806        /**
4807         * @return {@link #name} (Name of a rule or group to apply.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
4808         */
4809        public IdType getNameElement() { 
4810          if (this.name == null)
4811            if (Configuration.errorOnAutoCreate())
4812              throw new Error("Attempt to auto-create StructureMapGroupRuleDependentComponent.name");
4813            else if (Configuration.doAutoCreate())
4814              this.name = new IdType(); // bb
4815          return this.name;
4816        }
4817
4818        public boolean hasNameElement() { 
4819          return this.name != null && !this.name.isEmpty();
4820        }
4821
4822        public boolean hasName() { 
4823          return this.name != null && !this.name.isEmpty();
4824        }
4825
4826        /**
4827         * @param value {@link #name} (Name of a rule or group to apply.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
4828         */
4829        public StructureMapGroupRuleDependentComponent setNameElement(IdType value) { 
4830          this.name = value;
4831          return this;
4832        }
4833
4834        /**
4835         * @return Name of a rule or group to apply.
4836         */
4837        public String getName() { 
4838          return this.name == null ? null : this.name.getValue();
4839        }
4840
4841        /**
4842         * @param value Name of a rule or group to apply.
4843         */
4844        public StructureMapGroupRuleDependentComponent setName(String value) { 
4845            if (this.name == null)
4846              this.name = new IdType();
4847            this.name.setValue(value);
4848          return this;
4849        }
4850
4851        /**
4852         * @return {@link #parameter} (Parameter to pass to the rule or group.)
4853         */
4854        public List<StructureMapGroupRuleTargetParameterComponent> getParameter() { 
4855          if (this.parameter == null)
4856            this.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4857          return this.parameter;
4858        }
4859
4860        /**
4861         * @return Returns a reference to <code>this</code> for easy method chaining
4862         */
4863        public StructureMapGroupRuleDependentComponent setParameter(List<StructureMapGroupRuleTargetParameterComponent> theParameter) { 
4864          this.parameter = theParameter;
4865          return this;
4866        }
4867
4868        public boolean hasParameter() { 
4869          if (this.parameter == null)
4870            return false;
4871          for (StructureMapGroupRuleTargetParameterComponent item : this.parameter)
4872            if (!item.isEmpty())
4873              return true;
4874          return false;
4875        }
4876
4877        public StructureMapGroupRuleTargetParameterComponent addParameter() { //3
4878          StructureMapGroupRuleTargetParameterComponent t = new StructureMapGroupRuleTargetParameterComponent();
4879          if (this.parameter == null)
4880            this.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4881          this.parameter.add(t);
4882          return t;
4883        }
4884
4885        public StructureMapGroupRuleDependentComponent addParameter(StructureMapGroupRuleTargetParameterComponent t) { //3
4886          if (t == null)
4887            return this;
4888          if (this.parameter == null)
4889            this.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4890          this.parameter.add(t);
4891          return this;
4892        }
4893
4894        /**
4895         * @return The first repetition of repeating field {@link #parameter}, creating it if it does not already exist {3}
4896         */
4897        public StructureMapGroupRuleTargetParameterComponent getParameterFirstRep() { 
4898          if (getParameter().isEmpty()) {
4899            addParameter();
4900          }
4901          return getParameter().get(0);
4902        }
4903
4904        protected void listChildren(List<Property> children) {
4905          super.listChildren(children);
4906          children.add(new Property("name", "id", "Name of a rule or group to apply.", 0, 1, name));
4907          children.add(new Property("parameter", "@StructureMap.group.rule.target.parameter", "Parameter to pass to the rule or group.", 0, java.lang.Integer.MAX_VALUE, parameter));
4908        }
4909
4910        @Override
4911        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4912          switch (_hash) {
4913          case 3373707: /*name*/  return new Property("name", "id", "Name of a rule or group to apply.", 0, 1, name);
4914          case 1954460585: /*parameter*/  return new Property("parameter", "@StructureMap.group.rule.target.parameter", "Parameter to pass to the rule or group.", 0, java.lang.Integer.MAX_VALUE, parameter);
4915          default: return super.getNamedProperty(_hash, _name, _checkValid);
4916          }
4917
4918        }
4919
4920      @Override
4921      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4922        switch (hash) {
4923        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // IdType
4924        case 1954460585: /*parameter*/ return this.parameter == null ? new Base[0] : this.parameter.toArray(new Base[this.parameter.size()]); // StructureMapGroupRuleTargetParameterComponent
4925        default: return super.getProperty(hash, name, checkValid);
4926        }
4927
4928      }
4929
4930      @Override
4931      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4932        switch (hash) {
4933        case 3373707: // name
4934          this.name = TypeConvertor.castToId(value); // IdType
4935          return value;
4936        case 1954460585: // parameter
4937          this.getParameter().add((StructureMapGroupRuleTargetParameterComponent) value); // StructureMapGroupRuleTargetParameterComponent
4938          return value;
4939        default: return super.setProperty(hash, name, value);
4940        }
4941
4942      }
4943
4944      @Override
4945      public Base setProperty(String name, Base value) throws FHIRException {
4946        if (name.equals("name")) {
4947          this.name = TypeConvertor.castToId(value); // IdType
4948        } else if (name.equals("parameter")) {
4949          this.getParameter().add((StructureMapGroupRuleTargetParameterComponent) value);
4950        } else
4951          return super.setProperty(name, value);
4952        return value;
4953      }
4954
4955      @Override
4956      public Base makeProperty(int hash, String name) throws FHIRException {
4957        switch (hash) {
4958        case 3373707:  return getNameElement();
4959        case 1954460585:  return addParameter(); 
4960        default: return super.makeProperty(hash, name);
4961        }
4962
4963      }
4964
4965      @Override
4966      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4967        switch (hash) {
4968        case 3373707: /*name*/ return new String[] {"id"};
4969        case 1954460585: /*parameter*/ return new String[] {"@StructureMap.group.rule.target.parameter"};
4970        default: return super.getTypesForProperty(hash, name);
4971        }
4972
4973      }
4974
4975      @Override
4976      public Base addChild(String name) throws FHIRException {
4977        if (name.equals("name")) {
4978          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.group.rule.dependent.name");
4979        }
4980        else if (name.equals("parameter")) {
4981          return addParameter();
4982        }
4983        else
4984          return super.addChild(name);
4985      }
4986
4987      public StructureMapGroupRuleDependentComponent copy() {
4988        StructureMapGroupRuleDependentComponent dst = new StructureMapGroupRuleDependentComponent();
4989        copyValues(dst);
4990        return dst;
4991      }
4992
4993      public void copyValues(StructureMapGroupRuleDependentComponent dst) {
4994        super.copyValues(dst);
4995        dst.name = name == null ? null : name.copy();
4996        if (parameter != null) {
4997          dst.parameter = new ArrayList<StructureMapGroupRuleTargetParameterComponent>();
4998          for (StructureMapGroupRuleTargetParameterComponent i : parameter)
4999            dst.parameter.add(i.copy());
5000        };
5001      }
5002
5003      @Override
5004      public boolean equalsDeep(Base other_) {
5005        if (!super.equalsDeep(other_))
5006          return false;
5007        if (!(other_ instanceof StructureMapGroupRuleDependentComponent))
5008          return false;
5009        StructureMapGroupRuleDependentComponent o = (StructureMapGroupRuleDependentComponent) other_;
5010        return compareDeep(name, o.name, true) && compareDeep(parameter, o.parameter, true);
5011      }
5012
5013      @Override
5014      public boolean equalsShallow(Base other_) {
5015        if (!super.equalsShallow(other_))
5016          return false;
5017        if (!(other_ instanceof StructureMapGroupRuleDependentComponent))
5018          return false;
5019        StructureMapGroupRuleDependentComponent o = (StructureMapGroupRuleDependentComponent) other_;
5020        return compareValues(name, o.name, true);
5021      }
5022
5023      public boolean isEmpty() {
5024        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, parameter);
5025      }
5026
5027  public String fhirType() {
5028    return "StructureMap.group.rule.dependent";
5029
5030  }
5031
5032  }
5033
5034    /**
5035     * An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.
5036     */
5037    @Child(name = "url", type = {UriType.class}, order=0, min=1, max=1, modifier=false, summary=true)
5038    @Description(shortDefinition="Canonical identifier for this structure map, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers." )
5039    protected UriType url;
5040
5041    /**
5042     * A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance.
5043     */
5044    @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5045    @Description(shortDefinition="Additional identifier for the structure map", formalDefinition="A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance." )
5046    protected List<Identifier> identifier;
5047
5048    /**
5049     * The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
5050     */
5051    @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
5052    @Description(shortDefinition="Business version of the structure map", formalDefinition="The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence." )
5053    protected StringType version;
5054
5055    /**
5056     * Indicates the mechanism used to compare versions to determine which is more current.
5057     */
5058    @Child(name = "versionAlgorithm", type = {StringType.class, Coding.class}, order=3, min=0, max=1, modifier=false, summary=true)
5059    @Description(shortDefinition="How to compare versions", formalDefinition="Indicates the mechanism used to compare versions to determine which is more current." )
5060    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/version-algorithm")
5061    protected DataType versionAlgorithm;
5062
5063    /**
5064     * A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.
5065     */
5066    @Child(name = "name", type = {StringType.class}, order=4, min=1, max=1, modifier=false, summary=true)
5067    @Description(shortDefinition="Name for this structure map (computer friendly)", formalDefinition="A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation." )
5068    protected StringType name;
5069
5070    /**
5071     * A short, descriptive, user-friendly title for the structure map.
5072     */
5073    @Child(name = "title", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
5074    @Description(shortDefinition="Name for this structure map (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the structure map." )
5075    protected StringType title;
5076
5077    /**
5078     * The status of this structure map. Enables tracking the life-cycle of the content.
5079     */
5080    @Child(name = "status", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true)
5081    @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this structure map. Enables tracking the life-cycle of the content." )
5082    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status")
5083    protected Enumeration<PublicationStatus> status;
5084
5085    /**
5086     * A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
5087     */
5088    @Child(name = "experimental", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=true)
5089    @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." )
5090    protected BooleanType experimental;
5091
5092    /**
5093     * The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.
5094     */
5095    @Child(name = "date", type = {DateTimeType.class}, order=8, min=0, max=1, modifier=false, summary=true)
5096    @Description(shortDefinition="Date last changed", formalDefinition="The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes." )
5097    protected DateTimeType date;
5098
5099    /**
5100     * The name of the organization or individual responsible for the release and ongoing maintenance of the structure map.
5101     */
5102    @Child(name = "publisher", type = {StringType.class}, order=9, min=0, max=1, modifier=false, summary=true)
5103    @Description(shortDefinition="Name of the publisher/steward (organization or individual)", formalDefinition="The name of the organization or individual responsible for the release and ongoing maintenance of the structure map." )
5104    protected StringType publisher;
5105
5106    /**
5107     * Contact details to assist a user in finding and communicating with the publisher.
5108     */
5109    @Child(name = "contact", type = {ContactDetail.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5110    @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." )
5111    protected List<ContactDetail> contact;
5112
5113    /**
5114     * A free text natural language description of the structure map from a consumer's perspective.
5115     */
5116    @Child(name = "description", type = {MarkdownType.class}, order=11, min=0, max=1, modifier=false, summary=false)
5117    @Description(shortDefinition="Natural language description of the structure map", formalDefinition="A free text natural language description of the structure map from a consumer's perspective." )
5118    protected MarkdownType description;
5119
5120    /**
5121     * The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate structure map instances.
5122     */
5123    @Child(name = "useContext", type = {UsageContext.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5124    @Description(shortDefinition="The context that the content is intended to support", formalDefinition="The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate structure map instances." )
5125    protected List<UsageContext> useContext;
5126
5127    /**
5128     * A legal or geographic region in which the structure map is intended to be used.
5129     */
5130    @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5131    @Description(shortDefinition="Intended jurisdiction for structure map (if applicable)", formalDefinition="A legal or geographic region in which the structure map is intended to be used." )
5132    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction")
5133    protected List<CodeableConcept> jurisdiction;
5134
5135    /**
5136     * Explanation of why this structure map is needed and why it has been designed as it has.
5137     */
5138    @Child(name = "purpose", type = {MarkdownType.class}, order=14, min=0, max=1, modifier=false, summary=false)
5139    @Description(shortDefinition="Why this structure map is defined", formalDefinition="Explanation of why this structure map is needed and why it has been designed as it has." )
5140    protected MarkdownType purpose;
5141
5142    /**
5143     * A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.
5144     */
5145    @Child(name = "copyright", type = {MarkdownType.class}, order=15, min=0, max=1, modifier=false, summary=false)
5146    @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map." )
5147    protected MarkdownType copyright;
5148
5149    /**
5150     * A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').
5151     */
5152    @Child(name = "copyrightLabel", type = {StringType.class}, order=16, min=0, max=1, modifier=false, summary=false)
5153    @Description(shortDefinition="Copyright holder and year(s)", formalDefinition="A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved')." )
5154    protected StringType copyrightLabel;
5155
5156    /**
5157     * A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced.
5158     */
5159    @Child(name = "structure", type = {}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5160    @Description(shortDefinition="Structure Definition used by this map", formalDefinition="A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced." )
5161    protected List<StructureMapStructureComponent> structure;
5162
5163    /**
5164     * Other maps used by this map (canonical URLs).
5165     */
5166    @Child(name = "import", type = {CanonicalType.class}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5167    @Description(shortDefinition="Other maps used by this map (canonical URLs)", formalDefinition="Other maps used by this map (canonical URLs)." )
5168    protected List<CanonicalType> import_;
5169
5170    /**
5171     * Organizes the mapping into manageable chunks for human review/ease of maintenance.
5172     */
5173    @Child(name = "group", type = {}, order=19, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5174    @Description(shortDefinition="Named sections for reader convenience", formalDefinition="Organizes the mapping into manageable chunks for human review/ease of maintenance." )
5175    protected List<StructureMapGroupComponent> group;
5176
5177    private static final long serialVersionUID = 694707734L;
5178
5179  /**
5180   * Constructor
5181   */
5182    public StructureMap() {
5183      super();
5184    }
5185
5186  /**
5187   * Constructor
5188   */
5189    public StructureMap(String url, String name, PublicationStatus status, StructureMapGroupComponent group) {
5190      super();
5191      this.setUrl(url);
5192      this.setName(name);
5193      this.setStatus(status);
5194      this.addGroup(group);
5195    }
5196
5197    /**
5198     * @return {@link #url} (An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
5199     */
5200    public UriType getUrlElement() { 
5201      if (this.url == null)
5202        if (Configuration.errorOnAutoCreate())
5203          throw new Error("Attempt to auto-create StructureMap.url");
5204        else if (Configuration.doAutoCreate())
5205          this.url = new UriType(); // bb
5206      return this.url;
5207    }
5208
5209    public boolean hasUrlElement() { 
5210      return this.url != null && !this.url.isEmpty();
5211    }
5212
5213    public boolean hasUrl() { 
5214      return this.url != null && !this.url.isEmpty();
5215    }
5216
5217    /**
5218     * @param value {@link #url} (An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
5219     */
5220    public StructureMap setUrlElement(UriType value) { 
5221      this.url = value;
5222      return this;
5223    }
5224
5225    /**
5226     * @return An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.
5227     */
5228    public String getUrl() { 
5229      return this.url == null ? null : this.url.getValue();
5230    }
5231
5232    /**
5233     * @param value An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.
5234     */
5235    public StructureMap setUrl(String value) { 
5236        if (this.url == null)
5237          this.url = new UriType();
5238        this.url.setValue(value);
5239      return this;
5240    }
5241
5242    /**
5243     * @return {@link #identifier} (A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance.)
5244     */
5245    public List<Identifier> getIdentifier() { 
5246      if (this.identifier == null)
5247        this.identifier = new ArrayList<Identifier>();
5248      return this.identifier;
5249    }
5250
5251    /**
5252     * @return Returns a reference to <code>this</code> for easy method chaining
5253     */
5254    public StructureMap setIdentifier(List<Identifier> theIdentifier) { 
5255      this.identifier = theIdentifier;
5256      return this;
5257    }
5258
5259    public boolean hasIdentifier() { 
5260      if (this.identifier == null)
5261        return false;
5262      for (Identifier item : this.identifier)
5263        if (!item.isEmpty())
5264          return true;
5265      return false;
5266    }
5267
5268    public Identifier addIdentifier() { //3
5269      Identifier t = new Identifier();
5270      if (this.identifier == null)
5271        this.identifier = new ArrayList<Identifier>();
5272      this.identifier.add(t);
5273      return t;
5274    }
5275
5276    public StructureMap addIdentifier(Identifier t) { //3
5277      if (t == null)
5278        return this;
5279      if (this.identifier == null)
5280        this.identifier = new ArrayList<Identifier>();
5281      this.identifier.add(t);
5282      return this;
5283    }
5284
5285    /**
5286     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
5287     */
5288    public Identifier getIdentifierFirstRep() { 
5289      if (getIdentifier().isEmpty()) {
5290        addIdentifier();
5291      }
5292      return getIdentifier().get(0);
5293    }
5294
5295    /**
5296     * @return {@link #version} (The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
5297     */
5298    public StringType getVersionElement() { 
5299      if (this.version == null)
5300        if (Configuration.errorOnAutoCreate())
5301          throw new Error("Attempt to auto-create StructureMap.version");
5302        else if (Configuration.doAutoCreate())
5303          this.version = new StringType(); // bb
5304      return this.version;
5305    }
5306
5307    public boolean hasVersionElement() { 
5308      return this.version != null && !this.version.isEmpty();
5309    }
5310
5311    public boolean hasVersion() { 
5312      return this.version != null && !this.version.isEmpty();
5313    }
5314
5315    /**
5316     * @param value {@link #version} (The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
5317     */
5318    public StructureMap setVersionElement(StringType value) { 
5319      this.version = value;
5320      return this;
5321    }
5322
5323    /**
5324     * @return The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
5325     */
5326    public String getVersion() { 
5327      return this.version == null ? null : this.version.getValue();
5328    }
5329
5330    /**
5331     * @param value The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
5332     */
5333    public StructureMap setVersion(String value) { 
5334      if (Utilities.noString(value))
5335        this.version = null;
5336      else {
5337        if (this.version == null)
5338          this.version = new StringType();
5339        this.version.setValue(value);
5340      }
5341      return this;
5342    }
5343
5344    /**
5345     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5346     */
5347    public DataType getVersionAlgorithm() { 
5348      return this.versionAlgorithm;
5349    }
5350
5351    /**
5352     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5353     */
5354    public StringType getVersionAlgorithmStringType() throws FHIRException { 
5355      if (this.versionAlgorithm == null)
5356        this.versionAlgorithm = new StringType();
5357      if (!(this.versionAlgorithm instanceof StringType))
5358        throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.versionAlgorithm.getClass().getName()+" was encountered");
5359      return (StringType) this.versionAlgorithm;
5360    }
5361
5362    public boolean hasVersionAlgorithmStringType() { 
5363      return this != null && this.versionAlgorithm instanceof StringType;
5364    }
5365
5366    /**
5367     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5368     */
5369    public Coding getVersionAlgorithmCoding() throws FHIRException { 
5370      if (this.versionAlgorithm == null)
5371        this.versionAlgorithm = new Coding();
5372      if (!(this.versionAlgorithm instanceof Coding))
5373        throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.versionAlgorithm.getClass().getName()+" was encountered");
5374      return (Coding) this.versionAlgorithm;
5375    }
5376
5377    public boolean hasVersionAlgorithmCoding() { 
5378      return this != null && this.versionAlgorithm instanceof Coding;
5379    }
5380
5381    public boolean hasVersionAlgorithm() { 
5382      return this.versionAlgorithm != null && !this.versionAlgorithm.isEmpty();
5383    }
5384
5385    /**
5386     * @param value {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5387     */
5388    public StructureMap setVersionAlgorithm(DataType value) { 
5389      if (value != null && !(value instanceof StringType || value instanceof Coding))
5390        throw new Error("Not the right type for StructureMap.versionAlgorithm[x]: "+value.fhirType());
5391      this.versionAlgorithm = value;
5392      return this;
5393    }
5394
5395    /**
5396     * @return {@link #name} (A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
5397     */
5398    public StringType getNameElement() { 
5399      if (this.name == null)
5400        if (Configuration.errorOnAutoCreate())
5401          throw new Error("Attempt to auto-create StructureMap.name");
5402        else if (Configuration.doAutoCreate())
5403          this.name = new StringType(); // bb
5404      return this.name;
5405    }
5406
5407    public boolean hasNameElement() { 
5408      return this.name != null && !this.name.isEmpty();
5409    }
5410
5411    public boolean hasName() { 
5412      return this.name != null && !this.name.isEmpty();
5413    }
5414
5415    /**
5416     * @param value {@link #name} (A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
5417     */
5418    public StructureMap setNameElement(StringType value) { 
5419      this.name = value;
5420      return this;
5421    }
5422
5423    /**
5424     * @return A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.
5425     */
5426    public String getName() { 
5427      return this.name == null ? null : this.name.getValue();
5428    }
5429
5430    /**
5431     * @param value A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.
5432     */
5433    public StructureMap setName(String value) { 
5434        if (this.name == null)
5435          this.name = new StringType();
5436        this.name.setValue(value);
5437      return this;
5438    }
5439
5440    /**
5441     * @return {@link #title} (A short, descriptive, user-friendly title for the structure map.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
5442     */
5443    public StringType getTitleElement() { 
5444      if (this.title == null)
5445        if (Configuration.errorOnAutoCreate())
5446          throw new Error("Attempt to auto-create StructureMap.title");
5447        else if (Configuration.doAutoCreate())
5448          this.title = new StringType(); // bb
5449      return this.title;
5450    }
5451
5452    public boolean hasTitleElement() { 
5453      return this.title != null && !this.title.isEmpty();
5454    }
5455
5456    public boolean hasTitle() { 
5457      return this.title != null && !this.title.isEmpty();
5458    }
5459
5460    /**
5461     * @param value {@link #title} (A short, descriptive, user-friendly title for the structure map.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
5462     */
5463    public StructureMap setTitleElement(StringType value) { 
5464      this.title = value;
5465      return this;
5466    }
5467
5468    /**
5469     * @return A short, descriptive, user-friendly title for the structure map.
5470     */
5471    public String getTitle() { 
5472      return this.title == null ? null : this.title.getValue();
5473    }
5474
5475    /**
5476     * @param value A short, descriptive, user-friendly title for the structure map.
5477     */
5478    public StructureMap setTitle(String value) { 
5479      if (Utilities.noString(value))
5480        this.title = null;
5481      else {
5482        if (this.title == null)
5483          this.title = new StringType();
5484        this.title.setValue(value);
5485      }
5486      return this;
5487    }
5488
5489    /**
5490     * @return {@link #status} (The status of this structure map. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
5491     */
5492    public Enumeration<PublicationStatus> getStatusElement() { 
5493      if (this.status == null)
5494        if (Configuration.errorOnAutoCreate())
5495          throw new Error("Attempt to auto-create StructureMap.status");
5496        else if (Configuration.doAutoCreate())
5497          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
5498      return this.status;
5499    }
5500
5501    public boolean hasStatusElement() { 
5502      return this.status != null && !this.status.isEmpty();
5503    }
5504
5505    public boolean hasStatus() { 
5506      return this.status != null && !this.status.isEmpty();
5507    }
5508
5509    /**
5510     * @param value {@link #status} (The status of this structure map. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
5511     */
5512    public StructureMap setStatusElement(Enumeration<PublicationStatus> value) { 
5513      this.status = value;
5514      return this;
5515    }
5516
5517    /**
5518     * @return The status of this structure map. Enables tracking the life-cycle of the content.
5519     */
5520    public PublicationStatus getStatus() { 
5521      return this.status == null ? null : this.status.getValue();
5522    }
5523
5524    /**
5525     * @param value The status of this structure map. Enables tracking the life-cycle of the content.
5526     */
5527    public StructureMap setStatus(PublicationStatus value) { 
5528        if (this.status == null)
5529          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
5530        this.status.setValue(value);
5531      return this;
5532    }
5533
5534    /**
5535     * @return {@link #experimental} (A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
5536     */
5537    public BooleanType getExperimentalElement() { 
5538      if (this.experimental == null)
5539        if (Configuration.errorOnAutoCreate())
5540          throw new Error("Attempt to auto-create StructureMap.experimental");
5541        else if (Configuration.doAutoCreate())
5542          this.experimental = new BooleanType(); // bb
5543      return this.experimental;
5544    }
5545
5546    public boolean hasExperimentalElement() { 
5547      return this.experimental != null && !this.experimental.isEmpty();
5548    }
5549
5550    public boolean hasExperimental() { 
5551      return this.experimental != null && !this.experimental.isEmpty();
5552    }
5553
5554    /**
5555     * @param value {@link #experimental} (A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
5556     */
5557    public StructureMap setExperimentalElement(BooleanType value) { 
5558      this.experimental = value;
5559      return this;
5560    }
5561
5562    /**
5563     * @return A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
5564     */
5565    public boolean getExperimental() { 
5566      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
5567    }
5568
5569    /**
5570     * @param value A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
5571     */
5572    public StructureMap setExperimental(boolean value) { 
5573        if (this.experimental == null)
5574          this.experimental = new BooleanType();
5575        this.experimental.setValue(value);
5576      return this;
5577    }
5578
5579    /**
5580     * @return {@link #date} (The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
5581     */
5582    public DateTimeType getDateElement() { 
5583      if (this.date == null)
5584        if (Configuration.errorOnAutoCreate())
5585          throw new Error("Attempt to auto-create StructureMap.date");
5586        else if (Configuration.doAutoCreate())
5587          this.date = new DateTimeType(); // bb
5588      return this.date;
5589    }
5590
5591    public boolean hasDateElement() { 
5592      return this.date != null && !this.date.isEmpty();
5593    }
5594
5595    public boolean hasDate() { 
5596      return this.date != null && !this.date.isEmpty();
5597    }
5598
5599    /**
5600     * @param value {@link #date} (The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
5601     */
5602    public StructureMap setDateElement(DateTimeType value) { 
5603      this.date = value;
5604      return this;
5605    }
5606
5607    /**
5608     * @return The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.
5609     */
5610    public Date getDate() { 
5611      return this.date == null ? null : this.date.getValue();
5612    }
5613
5614    /**
5615     * @param value The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.
5616     */
5617    public StructureMap setDate(Date value) { 
5618      if (value == null)
5619        this.date = null;
5620      else {
5621        if (this.date == null)
5622          this.date = new DateTimeType();
5623        this.date.setValue(value);
5624      }
5625      return this;
5626    }
5627
5628    /**
5629     * @return {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the structure map.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
5630     */
5631    public StringType getPublisherElement() { 
5632      if (this.publisher == null)
5633        if (Configuration.errorOnAutoCreate())
5634          throw new Error("Attempt to auto-create StructureMap.publisher");
5635        else if (Configuration.doAutoCreate())
5636          this.publisher = new StringType(); // bb
5637      return this.publisher;
5638    }
5639
5640    public boolean hasPublisherElement() { 
5641      return this.publisher != null && !this.publisher.isEmpty();
5642    }
5643
5644    public boolean hasPublisher() { 
5645      return this.publisher != null && !this.publisher.isEmpty();
5646    }
5647
5648    /**
5649     * @param value {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the structure map.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
5650     */
5651    public StructureMap setPublisherElement(StringType value) { 
5652      this.publisher = value;
5653      return this;
5654    }
5655
5656    /**
5657     * @return The name of the organization or individual responsible for the release and ongoing maintenance of the structure map.
5658     */
5659    public String getPublisher() { 
5660      return this.publisher == null ? null : this.publisher.getValue();
5661    }
5662
5663    /**
5664     * @param value The name of the organization or individual responsible for the release and ongoing maintenance of the structure map.
5665     */
5666    public StructureMap setPublisher(String value) { 
5667      if (Utilities.noString(value))
5668        this.publisher = null;
5669      else {
5670        if (this.publisher == null)
5671          this.publisher = new StringType();
5672        this.publisher.setValue(value);
5673      }
5674      return this;
5675    }
5676
5677    /**
5678     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
5679     */
5680    public List<ContactDetail> getContact() { 
5681      if (this.contact == null)
5682        this.contact = new ArrayList<ContactDetail>();
5683      return this.contact;
5684    }
5685
5686    /**
5687     * @return Returns a reference to <code>this</code> for easy method chaining
5688     */
5689    public StructureMap setContact(List<ContactDetail> theContact) { 
5690      this.contact = theContact;
5691      return this;
5692    }
5693
5694    public boolean hasContact() { 
5695      if (this.contact == null)
5696        return false;
5697      for (ContactDetail item : this.contact)
5698        if (!item.isEmpty())
5699          return true;
5700      return false;
5701    }
5702
5703    public ContactDetail addContact() { //3
5704      ContactDetail t = new ContactDetail();
5705      if (this.contact == null)
5706        this.contact = new ArrayList<ContactDetail>();
5707      this.contact.add(t);
5708      return t;
5709    }
5710
5711    public StructureMap addContact(ContactDetail t) { //3
5712      if (t == null)
5713        return this;
5714      if (this.contact == null)
5715        this.contact = new ArrayList<ContactDetail>();
5716      this.contact.add(t);
5717      return this;
5718    }
5719
5720    /**
5721     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
5722     */
5723    public ContactDetail getContactFirstRep() { 
5724      if (getContact().isEmpty()) {
5725        addContact();
5726      }
5727      return getContact().get(0);
5728    }
5729
5730    /**
5731     * @return {@link #description} (A free text natural language description of the structure map from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
5732     */
5733    public MarkdownType getDescriptionElement() { 
5734      if (this.description == null)
5735        if (Configuration.errorOnAutoCreate())
5736          throw new Error("Attempt to auto-create StructureMap.description");
5737        else if (Configuration.doAutoCreate())
5738          this.description = new MarkdownType(); // bb
5739      return this.description;
5740    }
5741
5742    public boolean hasDescriptionElement() { 
5743      return this.description != null && !this.description.isEmpty();
5744    }
5745
5746    public boolean hasDescription() { 
5747      return this.description != null && !this.description.isEmpty();
5748    }
5749
5750    /**
5751     * @param value {@link #description} (A free text natural language description of the structure map from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
5752     */
5753    public StructureMap setDescriptionElement(MarkdownType value) { 
5754      this.description = value;
5755      return this;
5756    }
5757
5758    /**
5759     * @return A free text natural language description of the structure map from a consumer's perspective.
5760     */
5761    public String getDescription() { 
5762      return this.description == null ? null : this.description.getValue();
5763    }
5764
5765    /**
5766     * @param value A free text natural language description of the structure map from a consumer's perspective.
5767     */
5768    public StructureMap setDescription(String value) { 
5769      if (value == null)
5770        this.description = null;
5771      else {
5772        if (this.description == null)
5773          this.description = new MarkdownType();
5774        this.description.setValue(value);
5775      }
5776      return this;
5777    }
5778
5779    /**
5780     * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate structure map instances.)
5781     */
5782    public List<UsageContext> getUseContext() { 
5783      if (this.useContext == null)
5784        this.useContext = new ArrayList<UsageContext>();
5785      return this.useContext;
5786    }
5787
5788    /**
5789     * @return Returns a reference to <code>this</code> for easy method chaining
5790     */
5791    public StructureMap setUseContext(List<UsageContext> theUseContext) { 
5792      this.useContext = theUseContext;
5793      return this;
5794    }
5795
5796    public boolean hasUseContext() { 
5797      if (this.useContext == null)
5798        return false;
5799      for (UsageContext item : this.useContext)
5800        if (!item.isEmpty())
5801          return true;
5802      return false;
5803    }
5804
5805    public UsageContext addUseContext() { //3
5806      UsageContext t = new UsageContext();
5807      if (this.useContext == null)
5808        this.useContext = new ArrayList<UsageContext>();
5809      this.useContext.add(t);
5810      return t;
5811    }
5812
5813    public StructureMap addUseContext(UsageContext t) { //3
5814      if (t == null)
5815        return this;
5816      if (this.useContext == null)
5817        this.useContext = new ArrayList<UsageContext>();
5818      this.useContext.add(t);
5819      return this;
5820    }
5821
5822    /**
5823     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3}
5824     */
5825    public UsageContext getUseContextFirstRep() { 
5826      if (getUseContext().isEmpty()) {
5827        addUseContext();
5828      }
5829      return getUseContext().get(0);
5830    }
5831
5832    /**
5833     * @return {@link #jurisdiction} (A legal or geographic region in which the structure map is intended to be used.)
5834     */
5835    public List<CodeableConcept> getJurisdiction() { 
5836      if (this.jurisdiction == null)
5837        this.jurisdiction = new ArrayList<CodeableConcept>();
5838      return this.jurisdiction;
5839    }
5840
5841    /**
5842     * @return Returns a reference to <code>this</code> for easy method chaining
5843     */
5844    public StructureMap setJurisdiction(List<CodeableConcept> theJurisdiction) { 
5845      this.jurisdiction = theJurisdiction;
5846      return this;
5847    }
5848
5849    public boolean hasJurisdiction() { 
5850      if (this.jurisdiction == null)
5851        return false;
5852      for (CodeableConcept item : this.jurisdiction)
5853        if (!item.isEmpty())
5854          return true;
5855      return false;
5856    }
5857
5858    public CodeableConcept addJurisdiction() { //3
5859      CodeableConcept t = new CodeableConcept();
5860      if (this.jurisdiction == null)
5861        this.jurisdiction = new ArrayList<CodeableConcept>();
5862      this.jurisdiction.add(t);
5863      return t;
5864    }
5865
5866    public StructureMap addJurisdiction(CodeableConcept t) { //3
5867      if (t == null)
5868        return this;
5869      if (this.jurisdiction == null)
5870        this.jurisdiction = new ArrayList<CodeableConcept>();
5871      this.jurisdiction.add(t);
5872      return this;
5873    }
5874
5875    /**
5876     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3}
5877     */
5878    public CodeableConcept getJurisdictionFirstRep() { 
5879      if (getJurisdiction().isEmpty()) {
5880        addJurisdiction();
5881      }
5882      return getJurisdiction().get(0);
5883    }
5884
5885    /**
5886     * @return {@link #purpose} (Explanation of why this structure map is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
5887     */
5888    public MarkdownType getPurposeElement() { 
5889      if (this.purpose == null)
5890        if (Configuration.errorOnAutoCreate())
5891          throw new Error("Attempt to auto-create StructureMap.purpose");
5892        else if (Configuration.doAutoCreate())
5893          this.purpose = new MarkdownType(); // bb
5894      return this.purpose;
5895    }
5896
5897    public boolean hasPurposeElement() { 
5898      return this.purpose != null && !this.purpose.isEmpty();
5899    }
5900
5901    public boolean hasPurpose() { 
5902      return this.purpose != null && !this.purpose.isEmpty();
5903    }
5904
5905    /**
5906     * @param value {@link #purpose} (Explanation of why this structure map is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
5907     */
5908    public StructureMap setPurposeElement(MarkdownType value) { 
5909      this.purpose = value;
5910      return this;
5911    }
5912
5913    /**
5914     * @return Explanation of why this structure map is needed and why it has been designed as it has.
5915     */
5916    public String getPurpose() { 
5917      return this.purpose == null ? null : this.purpose.getValue();
5918    }
5919
5920    /**
5921     * @param value Explanation of why this structure map is needed and why it has been designed as it has.
5922     */
5923    public StructureMap setPurpose(String value) { 
5924      if (value == null)
5925        this.purpose = null;
5926      else {
5927        if (this.purpose == null)
5928          this.purpose = new MarkdownType();
5929        this.purpose.setValue(value);
5930      }
5931      return this;
5932    }
5933
5934    /**
5935     * @return {@link #copyright} (A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
5936     */
5937    public MarkdownType getCopyrightElement() { 
5938      if (this.copyright == null)
5939        if (Configuration.errorOnAutoCreate())
5940          throw new Error("Attempt to auto-create StructureMap.copyright");
5941        else if (Configuration.doAutoCreate())
5942          this.copyright = new MarkdownType(); // bb
5943      return this.copyright;
5944    }
5945
5946    public boolean hasCopyrightElement() { 
5947      return this.copyright != null && !this.copyright.isEmpty();
5948    }
5949
5950    public boolean hasCopyright() { 
5951      return this.copyright != null && !this.copyright.isEmpty();
5952    }
5953
5954    /**
5955     * @param value {@link #copyright} (A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
5956     */
5957    public StructureMap setCopyrightElement(MarkdownType value) { 
5958      this.copyright = value;
5959      return this;
5960    }
5961
5962    /**
5963     * @return A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.
5964     */
5965    public String getCopyright() { 
5966      return this.copyright == null ? null : this.copyright.getValue();
5967    }
5968
5969    /**
5970     * @param value A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.
5971     */
5972    public StructureMap setCopyright(String value) { 
5973      if (value == null)
5974        this.copyright = null;
5975      else {
5976        if (this.copyright == null)
5977          this.copyright = new MarkdownType();
5978        this.copyright.setValue(value);
5979      }
5980      return this;
5981    }
5982
5983    /**
5984     * @return {@link #copyrightLabel} (A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').). This is the underlying object with id, value and extensions. The accessor "getCopyrightLabel" gives direct access to the value
5985     */
5986    public StringType getCopyrightLabelElement() { 
5987      if (this.copyrightLabel == null)
5988        if (Configuration.errorOnAutoCreate())
5989          throw new Error("Attempt to auto-create StructureMap.copyrightLabel");
5990        else if (Configuration.doAutoCreate())
5991          this.copyrightLabel = new StringType(); // bb
5992      return this.copyrightLabel;
5993    }
5994
5995    public boolean hasCopyrightLabelElement() { 
5996      return this.copyrightLabel != null && !this.copyrightLabel.isEmpty();
5997    }
5998
5999    public boolean hasCopyrightLabel() { 
6000      return this.copyrightLabel != null && !this.copyrightLabel.isEmpty();
6001    }
6002
6003    /**
6004     * @param value {@link #copyrightLabel} (A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').). This is the underlying object with id, value and extensions. The accessor "getCopyrightLabel" gives direct access to the value
6005     */
6006    public StructureMap setCopyrightLabelElement(StringType value) { 
6007      this.copyrightLabel = value;
6008      return this;
6009    }
6010
6011    /**
6012     * @return A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').
6013     */
6014    public String getCopyrightLabel() { 
6015      return this.copyrightLabel == null ? null : this.copyrightLabel.getValue();
6016    }
6017
6018    /**
6019     * @param value A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').
6020     */
6021    public StructureMap setCopyrightLabel(String value) { 
6022      if (Utilities.noString(value))
6023        this.copyrightLabel = null;
6024      else {
6025        if (this.copyrightLabel == null)
6026          this.copyrightLabel = new StringType();
6027        this.copyrightLabel.setValue(value);
6028      }
6029      return this;
6030    }
6031
6032    /**
6033     * @return {@link #structure} (A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced.)
6034     */
6035    public List<StructureMapStructureComponent> getStructure() { 
6036      if (this.structure == null)
6037        this.structure = new ArrayList<StructureMapStructureComponent>();
6038      return this.structure;
6039    }
6040
6041    /**
6042     * @return Returns a reference to <code>this</code> for easy method chaining
6043     */
6044    public StructureMap setStructure(List<StructureMapStructureComponent> theStructure) { 
6045      this.structure = theStructure;
6046      return this;
6047    }
6048
6049    public boolean hasStructure() { 
6050      if (this.structure == null)
6051        return false;
6052      for (StructureMapStructureComponent item : this.structure)
6053        if (!item.isEmpty())
6054          return true;
6055      return false;
6056    }
6057
6058    public StructureMapStructureComponent addStructure() { //3
6059      StructureMapStructureComponent t = new StructureMapStructureComponent();
6060      if (this.structure == null)
6061        this.structure = new ArrayList<StructureMapStructureComponent>();
6062      this.structure.add(t);
6063      return t;
6064    }
6065
6066    public StructureMap addStructure(StructureMapStructureComponent t) { //3
6067      if (t == null)
6068        return this;
6069      if (this.structure == null)
6070        this.structure = new ArrayList<StructureMapStructureComponent>();
6071      this.structure.add(t);
6072      return this;
6073    }
6074
6075    /**
6076     * @return The first repetition of repeating field {@link #structure}, creating it if it does not already exist {3}
6077     */
6078    public StructureMapStructureComponent getStructureFirstRep() { 
6079      if (getStructure().isEmpty()) {
6080        addStructure();
6081      }
6082      return getStructure().get(0);
6083    }
6084
6085    /**
6086     * @return {@link #import_} (Other maps used by this map (canonical URLs).)
6087     */
6088    public List<CanonicalType> getImport() { 
6089      if (this.import_ == null)
6090        this.import_ = new ArrayList<CanonicalType>();
6091      return this.import_;
6092    }
6093
6094    /**
6095     * @return Returns a reference to <code>this</code> for easy method chaining
6096     */
6097    public StructureMap setImport(List<CanonicalType> theImport) { 
6098      this.import_ = theImport;
6099      return this;
6100    }
6101
6102    public boolean hasImport() { 
6103      if (this.import_ == null)
6104        return false;
6105      for (CanonicalType item : this.import_)
6106        if (!item.isEmpty())
6107          return true;
6108      return false;
6109    }
6110
6111    /**
6112     * @return {@link #import_} (Other maps used by this map (canonical URLs).)
6113     */
6114    public CanonicalType addImportElement() {//2 
6115      CanonicalType t = new CanonicalType();
6116      if (this.import_ == null)
6117        this.import_ = new ArrayList<CanonicalType>();
6118      this.import_.add(t);
6119      return t;
6120    }
6121
6122    /**
6123     * @param value {@link #import_} (Other maps used by this map (canonical URLs).)
6124     */
6125    public StructureMap addImport(String value) { //1
6126      CanonicalType t = new CanonicalType();
6127      t.setValue(value);
6128      if (this.import_ == null)
6129        this.import_ = new ArrayList<CanonicalType>();
6130      this.import_.add(t);
6131      return this;
6132    }
6133
6134    /**
6135     * @param value {@link #import_} (Other maps used by this map (canonical URLs).)
6136     */
6137    public boolean hasImport(String value) { 
6138      if (this.import_ == null)
6139        return false;
6140      for (CanonicalType v : this.import_)
6141        if (v.getValue().equals(value)) // canonical
6142          return true;
6143      return false;
6144    }
6145
6146    /**
6147     * @return {@link #group} (Organizes the mapping into manageable chunks for human review/ease of maintenance.)
6148     */
6149    public List<StructureMapGroupComponent> getGroup() { 
6150      if (this.group == null)
6151        this.group = new ArrayList<StructureMapGroupComponent>();
6152      return this.group;
6153    }
6154
6155    /**
6156     * @return Returns a reference to <code>this</code> for easy method chaining
6157     */
6158    public StructureMap setGroup(List<StructureMapGroupComponent> theGroup) { 
6159      this.group = theGroup;
6160      return this;
6161    }
6162
6163    public boolean hasGroup() { 
6164      if (this.group == null)
6165        return false;
6166      for (StructureMapGroupComponent item : this.group)
6167        if (!item.isEmpty())
6168          return true;
6169      return false;
6170    }
6171
6172    public StructureMapGroupComponent addGroup() { //3
6173      StructureMapGroupComponent t = new StructureMapGroupComponent();
6174      if (this.group == null)
6175        this.group = new ArrayList<StructureMapGroupComponent>();
6176      this.group.add(t);
6177      return t;
6178    }
6179
6180    public StructureMap addGroup(StructureMapGroupComponent t) { //3
6181      if (t == null)
6182        return this;
6183      if (this.group == null)
6184        this.group = new ArrayList<StructureMapGroupComponent>();
6185      this.group.add(t);
6186      return this;
6187    }
6188
6189    /**
6190     * @return The first repetition of repeating field {@link #group}, creating it if it does not already exist {3}
6191     */
6192    public StructureMapGroupComponent getGroupFirstRep() { 
6193      if (getGroup().isEmpty()) {
6194        addGroup();
6195      }
6196      return getGroup().get(0);
6197    }
6198
6199      protected void listChildren(List<Property> children) {
6200        super.listChildren(children);
6201        children.add(new Property("url", "uri", "An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.", 0, 1, url));
6202        children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier));
6203        children.add(new Property("version", "string", "The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version));
6204        children.add(new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm));
6205        children.add(new Property("name", "string", "A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
6206        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the structure map.", 0, 1, title));
6207        children.add(new Property("status", "code", "The status of this structure map. Enables tracking the life-cycle of the content.", 0, 1, status));
6208        children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental));
6209        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.", 0, 1, date));
6210        children.add(new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the structure map.", 0, 1, publisher));
6211        children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact));
6212        children.add(new Property("description", "markdown", "A free text natural language description of the structure map from a consumer's perspective.", 0, 1, description));
6213        children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate structure map instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
6214        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the structure map is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
6215        children.add(new Property("purpose", "markdown", "Explanation of why this structure map is needed and why it has been designed as it has.", 0, 1, purpose));
6216        children.add(new Property("copyright", "markdown", "A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.", 0, 1, copyright));
6217        children.add(new Property("copyrightLabel", "string", "A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').", 0, 1, copyrightLabel));
6218        children.add(new Property("structure", "", "A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced.", 0, java.lang.Integer.MAX_VALUE, structure));
6219        children.add(new Property("import", "canonical(StructureMap)", "Other maps used by this map (canonical URLs).", 0, java.lang.Integer.MAX_VALUE, import_));
6220        children.add(new Property("group", "", "Organizes the mapping into manageable chunks for human review/ease of maintenance.", 0, java.lang.Integer.MAX_VALUE, group));
6221      }
6222
6223      @Override
6224      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
6225        switch (_hash) {
6226        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this structure map is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure map is stored on different servers.", 0, 1, url);
6227        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier);
6228        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version);
6229        case -115699031: /*versionAlgorithm[x]*/  return new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
6230        case 1508158071: /*versionAlgorithm*/  return new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
6231        case 1836908904: /*versionAlgorithmString*/  return new Property("versionAlgorithm[x]", "string", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
6232        case 1373807809: /*versionAlgorithmCoding*/  return new Property("versionAlgorithm[x]", "Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
6233        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
6234        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the structure map.", 0, 1, title);
6235        case -892481550: /*status*/  return new Property("status", "code", "The status of this structure map. Enables tracking the life-cycle of the content.", 0, 1, status);
6236        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A Boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental);
6237        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the structure map was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.", 0, 1, date);
6238        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the structure map.", 0, 1, publisher);
6239        case 951526432: /*contact*/  return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact);
6240        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the structure map from a consumer's perspective.", 0, 1, description);
6241        case -669707736: /*useContext*/  return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate structure map instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
6242        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the structure map is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
6243        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explanation of why this structure map is needed and why it has been designed as it has.", 0, 1, purpose);
6244        case 1522889671: /*copyright*/  return new Property("copyright", "markdown", "A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.", 0, 1, copyright);
6245        case 765157229: /*copyrightLabel*/  return new Property("copyrightLabel", "string", "A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').", 0, 1, copyrightLabel);
6246        case 144518515: /*structure*/  return new Property("structure", "", "A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced.", 0, java.lang.Integer.MAX_VALUE, structure);
6247        case -1184795739: /*import*/  return new Property("import", "canonical(StructureMap)", "Other maps used by this map (canonical URLs).", 0, java.lang.Integer.MAX_VALUE, import_);
6248        case 98629247: /*group*/  return new Property("group", "", "Organizes the mapping into manageable chunks for human review/ease of maintenance.", 0, java.lang.Integer.MAX_VALUE, group);
6249        default: return super.getNamedProperty(_hash, _name, _checkValid);
6250        }
6251
6252      }
6253
6254      @Override
6255      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
6256        switch (hash) {
6257        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
6258        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
6259        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
6260        case 1508158071: /*versionAlgorithm*/ return this.versionAlgorithm == null ? new Base[0] : new Base[] {this.versionAlgorithm}; // DataType
6261        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
6262        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
6263        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
6264        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
6265        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
6266        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
6267        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
6268        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
6269        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
6270        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
6271        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
6272        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
6273        case 765157229: /*copyrightLabel*/ return this.copyrightLabel == null ? new Base[0] : new Base[] {this.copyrightLabel}; // StringType
6274        case 144518515: /*structure*/ return this.structure == null ? new Base[0] : this.structure.toArray(new Base[this.structure.size()]); // StructureMapStructureComponent
6275        case -1184795739: /*import*/ return this.import_ == null ? new Base[0] : this.import_.toArray(new Base[this.import_.size()]); // CanonicalType
6276        case 98629247: /*group*/ return this.group == null ? new Base[0] : this.group.toArray(new Base[this.group.size()]); // StructureMapGroupComponent
6277        default: return super.getProperty(hash, name, checkValid);
6278        }
6279
6280      }
6281
6282      @Override
6283      public Base setProperty(int hash, String name, Base value) throws FHIRException {
6284        switch (hash) {
6285        case 116079: // url
6286          this.url = TypeConvertor.castToUri(value); // UriType
6287          return value;
6288        case -1618432855: // identifier
6289          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
6290          return value;
6291        case 351608024: // version
6292          this.version = TypeConvertor.castToString(value); // StringType
6293          return value;
6294        case 1508158071: // versionAlgorithm
6295          this.versionAlgorithm = TypeConvertor.castToType(value); // DataType
6296          return value;
6297        case 3373707: // name
6298          this.name = TypeConvertor.castToString(value); // StringType
6299          return value;
6300        case 110371416: // title
6301          this.title = TypeConvertor.castToString(value); // StringType
6302          return value;
6303        case -892481550: // status
6304          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
6305          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
6306          return value;
6307        case -404562712: // experimental
6308          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
6309          return value;
6310        case 3076014: // date
6311          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
6312          return value;
6313        case 1447404028: // publisher
6314          this.publisher = TypeConvertor.castToString(value); // StringType
6315          return value;
6316        case 951526432: // contact
6317          this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail
6318          return value;
6319        case -1724546052: // description
6320          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
6321          return value;
6322        case -669707736: // useContext
6323          this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext
6324          return value;
6325        case -507075711: // jurisdiction
6326          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
6327          return value;
6328        case -220463842: // purpose
6329          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
6330          return value;
6331        case 1522889671: // copyright
6332          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
6333          return value;
6334        case 765157229: // copyrightLabel
6335          this.copyrightLabel = TypeConvertor.castToString(value); // StringType
6336          return value;
6337        case 144518515: // structure
6338          this.getStructure().add((StructureMapStructureComponent) value); // StructureMapStructureComponent
6339          return value;
6340        case -1184795739: // import
6341          this.getImport().add(TypeConvertor.castToCanonical(value)); // CanonicalType
6342          return value;
6343        case 98629247: // group
6344          this.getGroup().add((StructureMapGroupComponent) value); // StructureMapGroupComponent
6345          return value;
6346        default: return super.setProperty(hash, name, value);
6347        }
6348
6349      }
6350
6351      @Override
6352      public Base setProperty(String name, Base value) throws FHIRException {
6353        if (name.equals("url")) {
6354          this.url = TypeConvertor.castToUri(value); // UriType
6355        } else if (name.equals("identifier")) {
6356          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
6357        } else if (name.equals("version")) {
6358          this.version = TypeConvertor.castToString(value); // StringType
6359        } else if (name.equals("versionAlgorithm[x]")) {
6360          this.versionAlgorithm = TypeConvertor.castToType(value); // DataType
6361        } else if (name.equals("name")) {
6362          this.name = TypeConvertor.castToString(value); // StringType
6363        } else if (name.equals("title")) {
6364          this.title = TypeConvertor.castToString(value); // StringType
6365        } else if (name.equals("status")) {
6366          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
6367          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
6368        } else if (name.equals("experimental")) {
6369          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
6370        } else if (name.equals("date")) {
6371          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
6372        } else if (name.equals("publisher")) {
6373          this.publisher = TypeConvertor.castToString(value); // StringType
6374        } else if (name.equals("contact")) {
6375          this.getContact().add(TypeConvertor.castToContactDetail(value));
6376        } else if (name.equals("description")) {
6377          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
6378        } else if (name.equals("useContext")) {
6379          this.getUseContext().add(TypeConvertor.castToUsageContext(value));
6380        } else if (name.equals("jurisdiction")) {
6381          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value));
6382        } else if (name.equals("purpose")) {
6383          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
6384        } else if (name.equals("copyright")) {
6385          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
6386        } else if (name.equals("copyrightLabel")) {
6387          this.copyrightLabel = TypeConvertor.castToString(value); // StringType
6388        } else if (name.equals("structure")) {
6389          this.getStructure().add((StructureMapStructureComponent) value);
6390        } else if (name.equals("import")) {
6391          this.getImport().add(TypeConvertor.castToCanonical(value));
6392        } else if (name.equals("group")) {
6393          this.getGroup().add((StructureMapGroupComponent) value);
6394        } else
6395          return super.setProperty(name, value);
6396        return value;
6397      }
6398
6399      @Override
6400      public Base makeProperty(int hash, String name) throws FHIRException {
6401        switch (hash) {
6402        case 116079:  return getUrlElement();
6403        case -1618432855:  return addIdentifier(); 
6404        case 351608024:  return getVersionElement();
6405        case -115699031:  return getVersionAlgorithm();
6406        case 1508158071:  return getVersionAlgorithm();
6407        case 3373707:  return getNameElement();
6408        case 110371416:  return getTitleElement();
6409        case -892481550:  return getStatusElement();
6410        case -404562712:  return getExperimentalElement();
6411        case 3076014:  return getDateElement();
6412        case 1447404028:  return getPublisherElement();
6413        case 951526432:  return addContact(); 
6414        case -1724546052:  return getDescriptionElement();
6415        case -669707736:  return addUseContext(); 
6416        case -507075711:  return addJurisdiction(); 
6417        case -220463842:  return getPurposeElement();
6418        case 1522889671:  return getCopyrightElement();
6419        case 765157229:  return getCopyrightLabelElement();
6420        case 144518515:  return addStructure(); 
6421        case -1184795739:  return addImportElement();
6422        case 98629247:  return addGroup(); 
6423        default: return super.makeProperty(hash, name);
6424        }
6425
6426      }
6427
6428      @Override
6429      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6430        switch (hash) {
6431        case 116079: /*url*/ return new String[] {"uri"};
6432        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
6433        case 351608024: /*version*/ return new String[] {"string"};
6434        case 1508158071: /*versionAlgorithm*/ return new String[] {"string", "Coding"};
6435        case 3373707: /*name*/ return new String[] {"string"};
6436        case 110371416: /*title*/ return new String[] {"string"};
6437        case -892481550: /*status*/ return new String[] {"code"};
6438        case -404562712: /*experimental*/ return new String[] {"boolean"};
6439        case 3076014: /*date*/ return new String[] {"dateTime"};
6440        case 1447404028: /*publisher*/ return new String[] {"string"};
6441        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
6442        case -1724546052: /*description*/ return new String[] {"markdown"};
6443        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
6444        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
6445        case -220463842: /*purpose*/ return new String[] {"markdown"};
6446        case 1522889671: /*copyright*/ return new String[] {"markdown"};
6447        case 765157229: /*copyrightLabel*/ return new String[] {"string"};
6448        case 144518515: /*structure*/ return new String[] {};
6449        case -1184795739: /*import*/ return new String[] {"canonical"};
6450        case 98629247: /*group*/ return new String[] {};
6451        default: return super.getTypesForProperty(hash, name);
6452        }
6453
6454      }
6455
6456      @Override
6457      public Base addChild(String name) throws FHIRException {
6458        if (name.equals("url")) {
6459          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.url");
6460        }
6461        else if (name.equals("identifier")) {
6462          return addIdentifier();
6463        }
6464        else if (name.equals("version")) {
6465          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.version");
6466        }
6467        else if (name.equals("versionAlgorithmString")) {
6468          this.versionAlgorithm = new StringType();
6469          return this.versionAlgorithm;
6470        }
6471        else if (name.equals("versionAlgorithmCoding")) {
6472          this.versionAlgorithm = new Coding();
6473          return this.versionAlgorithm;
6474        }
6475        else if (name.equals("name")) {
6476          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.name");
6477        }
6478        else if (name.equals("title")) {
6479          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.title");
6480        }
6481        else if (name.equals("status")) {
6482          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.status");
6483        }
6484        else if (name.equals("experimental")) {
6485          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.experimental");
6486        }
6487        else if (name.equals("date")) {
6488          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.date");
6489        }
6490        else if (name.equals("publisher")) {
6491          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.publisher");
6492        }
6493        else if (name.equals("contact")) {
6494          return addContact();
6495        }
6496        else if (name.equals("description")) {
6497          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.description");
6498        }
6499        else if (name.equals("useContext")) {
6500          return addUseContext();
6501        }
6502        else if (name.equals("jurisdiction")) {
6503          return addJurisdiction();
6504        }
6505        else if (name.equals("purpose")) {
6506          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.purpose");
6507        }
6508        else if (name.equals("copyright")) {
6509          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.copyright");
6510        }
6511        else if (name.equals("copyrightLabel")) {
6512          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.copyrightLabel");
6513        }
6514        else if (name.equals("structure")) {
6515          return addStructure();
6516        }
6517        else if (name.equals("import")) {
6518          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.import");
6519        }
6520        else if (name.equals("group")) {
6521          return addGroup();
6522        }
6523        else
6524          return super.addChild(name);
6525      }
6526
6527  public String fhirType() {
6528    return "StructureMap";
6529
6530  }
6531
6532      public StructureMap copy() {
6533        StructureMap dst = new StructureMap();
6534        copyValues(dst);
6535        return dst;
6536      }
6537
6538      public void copyValues(StructureMap dst) {
6539        super.copyValues(dst);
6540        dst.url = url == null ? null : url.copy();
6541        if (identifier != null) {
6542          dst.identifier = new ArrayList<Identifier>();
6543          for (Identifier i : identifier)
6544            dst.identifier.add(i.copy());
6545        };
6546        dst.version = version == null ? null : version.copy();
6547        dst.versionAlgorithm = versionAlgorithm == null ? null : versionAlgorithm.copy();
6548        dst.name = name == null ? null : name.copy();
6549        dst.title = title == null ? null : title.copy();
6550        dst.status = status == null ? null : status.copy();
6551        dst.experimental = experimental == null ? null : experimental.copy();
6552        dst.date = date == null ? null : date.copy();
6553        dst.publisher = publisher == null ? null : publisher.copy();
6554        if (contact != null) {
6555          dst.contact = new ArrayList<ContactDetail>();
6556          for (ContactDetail i : contact)
6557            dst.contact.add(i.copy());
6558        };
6559        dst.description = description == null ? null : description.copy();
6560        if (useContext != null) {
6561          dst.useContext = new ArrayList<UsageContext>();
6562          for (UsageContext i : useContext)
6563            dst.useContext.add(i.copy());
6564        };
6565        if (jurisdiction != null) {
6566          dst.jurisdiction = new ArrayList<CodeableConcept>();
6567          for (CodeableConcept i : jurisdiction)
6568            dst.jurisdiction.add(i.copy());
6569        };
6570        dst.purpose = purpose == null ? null : purpose.copy();
6571        dst.copyright = copyright == null ? null : copyright.copy();
6572        dst.copyrightLabel = copyrightLabel == null ? null : copyrightLabel.copy();
6573        if (structure != null) {
6574          dst.structure = new ArrayList<StructureMapStructureComponent>();
6575          for (StructureMapStructureComponent i : structure)
6576            dst.structure.add(i.copy());
6577        };
6578        if (import_ != null) {
6579          dst.import_ = new ArrayList<CanonicalType>();
6580          for (CanonicalType i : import_)
6581            dst.import_.add(i.copy());
6582        };
6583        if (group != null) {
6584          dst.group = new ArrayList<StructureMapGroupComponent>();
6585          for (StructureMapGroupComponent i : group)
6586            dst.group.add(i.copy());
6587        };
6588      }
6589
6590      protected StructureMap typedCopy() {
6591        return copy();
6592      }
6593
6594      @Override
6595      public boolean equalsDeep(Base other_) {
6596        if (!super.equalsDeep(other_))
6597          return false;
6598        if (!(other_ instanceof StructureMap))
6599          return false;
6600        StructureMap o = (StructureMap) other_;
6601        return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true)
6602           && compareDeep(versionAlgorithm, o.versionAlgorithm, true) && compareDeep(name, o.name, true) && compareDeep(title, o.title, true)
6603           && compareDeep(status, o.status, true) && compareDeep(experimental, o.experimental, true) && compareDeep(date, o.date, true)
6604           && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) && compareDeep(description, o.description, true)
6605           && compareDeep(useContext, o.useContext, true) && compareDeep(jurisdiction, o.jurisdiction, true)
6606           && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) && compareDeep(copyrightLabel, o.copyrightLabel, true)
6607           && compareDeep(structure, o.structure, true) && compareDeep(import_, o.import_, true) && compareDeep(group, o.group, true)
6608          ;
6609      }
6610
6611      @Override
6612      public boolean equalsShallow(Base other_) {
6613        if (!super.equalsShallow(other_))
6614          return false;
6615        if (!(other_ instanceof StructureMap))
6616          return false;
6617        StructureMap o = (StructureMap) other_;
6618        return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true)
6619           && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true)
6620           && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true)
6621           && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(copyrightLabel, o.copyrightLabel, true)
6622           && compareValues(import_, o.import_, true);
6623      }
6624
6625      public boolean isEmpty() {
6626        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version
6627          , versionAlgorithm, name, title, status, experimental, date, publisher, contact
6628          , description, useContext, jurisdiction, purpose, copyright, copyrightLabel, structure
6629          , import_, group);
6630      }
6631
6632  @Override
6633  public ResourceType getResourceType() {
6634    return ResourceType.StructureMap;
6635   }
6636
6637 /**
6638   * Search parameter: <b>context-quantity</b>
6639   * <p>
6640   * Description: <b>Multiple Resources: 
6641
6642* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
6643* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
6644* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
6645* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
6646* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
6647* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
6648* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
6649* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
6650* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
6651* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
6652* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
6653* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
6654* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
6655* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
6656</b><br>
6657   * Type: <b>quantity</b><br>
6658   * Path: <b>(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)</b><br>
6659   * </p>
6660   */
6661  @SearchParamDefinition(name="context-quantity", path="(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set\r\n", type="quantity" )
6662  public static final String SP_CONTEXT_QUANTITY = "context-quantity";
6663 /**
6664   * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b>
6665   * <p>
6666   * Description: <b>Multiple Resources: 
6667
6668* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
6669* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
6670* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
6671* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
6672* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
6673* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
6674* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
6675* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
6676* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
6677* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
6678* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
6679* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
6680* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
6681* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
6682</b><br>
6683   * Type: <b>quantity</b><br>
6684   * Path: <b>(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)</b><br>
6685   * </p>
6686   */
6687  public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY);
6688
6689 /**
6690   * Search parameter: <b>context-type-quantity</b>
6691   * <p>
6692   * Description: <b>Multiple Resources: 
6693
6694* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
6695* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
6696* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
6697* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
6698* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
6699* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
6700* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
6701* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
6702* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
6703* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
6704* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
6705* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
6706* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
6707* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
6708</b><br>
6709   * Type: <b>composite</b><br>
6710   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6711   * </p>
6712   */
6713  @SearchParamDefinition(name="context-type-quantity", path="CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context-quantity"} )
6714  public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity";
6715 /**
6716   * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b>
6717   * <p>
6718   * Description: <b>Multiple Resources: 
6719
6720* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
6721* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
6722* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
6723* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
6724* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
6725* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
6726* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
6727* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
6728* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
6729* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
6730* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
6731* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
6732* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
6733* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
6734</b><br>
6735   * Type: <b>composite</b><br>
6736   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6737   * </p>
6738   */
6739  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam> CONTEXT_TYPE_QUANTITY = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam>(SP_CONTEXT_TYPE_QUANTITY);
6740
6741 /**
6742   * Search parameter: <b>context-type-value</b>
6743   * <p>
6744   * Description: <b>Multiple Resources: 
6745
6746* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
6747* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
6748* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
6749* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
6750* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
6751* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
6752* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
6753* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
6754* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
6755* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
6756* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
6757* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
6758* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
6759* [ValueSet](valueset.html): A use context type and value assigned to the value set
6760</b><br>
6761   * Type: <b>composite</b><br>
6762   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6763   * </p>
6764   */
6765  @SearchParamDefinition(name="context-type-value", path="CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context type and value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context type and value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context"} )
6766  public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value";
6767 /**
6768   * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b>
6769   * <p>
6770   * Description: <b>Multiple Resources: 
6771
6772* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
6773* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
6774* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
6775* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
6776* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
6777* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
6778* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
6779* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
6780* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
6781* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
6782* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
6783* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
6784* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
6785* [ValueSet](valueset.html): A use context type and value assigned to the value set
6786</b><br>
6787   * Type: <b>composite</b><br>
6788   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6789   * </p>
6790   */
6791  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>(SP_CONTEXT_TYPE_VALUE);
6792
6793 /**
6794   * Search parameter: <b>context-type</b>
6795   * <p>
6796   * Description: <b>Multiple Resources: 
6797
6798* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
6799* [CodeSystem](codesystem.html): A type of use context assigned to the code system
6800* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
6801* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
6802* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
6803* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
6804* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
6805* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
6806* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
6807* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
6808* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
6809* [StructureMap](structuremap.html): A type of use context assigned to the structure map
6810* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
6811* [ValueSet](valueset.html): A type of use context assigned to the value set
6812</b><br>
6813   * Type: <b>token</b><br>
6814   * Path: <b>CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code</b><br>
6815   * </p>
6816   */
6817  @SearchParamDefinition(name="context-type", path="CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A type of use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A type of use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A type of use context assigned to the value set\r\n", type="token" )
6818  public static final String SP_CONTEXT_TYPE = "context-type";
6819 /**
6820   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
6821   * <p>
6822   * Description: <b>Multiple Resources: 
6823
6824* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
6825* [CodeSystem](codesystem.html): A type of use context assigned to the code system
6826* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
6827* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
6828* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
6829* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
6830* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
6831* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
6832* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
6833* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
6834* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
6835* [StructureMap](structuremap.html): A type of use context assigned to the structure map
6836* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
6837* [ValueSet](valueset.html): A type of use context assigned to the value set
6838</b><br>
6839   * Type: <b>token</b><br>
6840   * Path: <b>CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code</b><br>
6841   * </p>
6842   */
6843  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE);
6844
6845 /**
6846   * Search parameter: <b>context</b>
6847   * <p>
6848   * Description: <b>Multiple Resources: 
6849
6850* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
6851* [CodeSystem](codesystem.html): A use context assigned to the code system
6852* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
6853* [ConceptMap](conceptmap.html): A use context assigned to the concept map
6854* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
6855* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
6856* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
6857* [NamingSystem](namingsystem.html): A use context assigned to the naming system
6858* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
6859* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
6860* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
6861* [StructureMap](structuremap.html): A use context assigned to the structure map
6862* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
6863* [ValueSet](valueset.html): A use context assigned to the value set
6864</b><br>
6865   * Type: <b>token</b><br>
6866   * Path: <b>(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)</b><br>
6867   * </p>
6868   */
6869  @SearchParamDefinition(name="context", path="(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context assigned to the value set\r\n", type="token" )
6870  public static final String SP_CONTEXT = "context";
6871 /**
6872   * <b>Fluent Client</b> search parameter constant for <b>context</b>
6873   * <p>
6874   * Description: <b>Multiple Resources: 
6875
6876* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
6877* [CodeSystem](codesystem.html): A use context assigned to the code system
6878* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
6879* [ConceptMap](conceptmap.html): A use context assigned to the concept map
6880* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
6881* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
6882* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
6883* [NamingSystem](namingsystem.html): A use context assigned to the naming system
6884* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
6885* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
6886* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
6887* [StructureMap](structuremap.html): A use context assigned to the structure map
6888* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
6889* [ValueSet](valueset.html): A use context assigned to the value set
6890</b><br>
6891   * Type: <b>token</b><br>
6892   * Path: <b>(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)</b><br>
6893   * </p>
6894   */
6895  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT);
6896
6897 /**
6898   * Search parameter: <b>date</b>
6899   * <p>
6900   * Description: <b>Multiple Resources: 
6901
6902* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
6903* [CodeSystem](codesystem.html): The code system publication date
6904* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
6905* [ConceptMap](conceptmap.html): The concept map publication date
6906* [GraphDefinition](graphdefinition.html): The graph definition publication date
6907* [ImplementationGuide](implementationguide.html): The implementation guide publication date
6908* [MessageDefinition](messagedefinition.html): The message definition publication date
6909* [NamingSystem](namingsystem.html): The naming system publication date
6910* [OperationDefinition](operationdefinition.html): The operation definition publication date
6911* [SearchParameter](searchparameter.html): The search parameter publication date
6912* [StructureDefinition](structuredefinition.html): The structure definition publication date
6913* [StructureMap](structuremap.html): The structure map publication date
6914* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
6915* [ValueSet](valueset.html): The value set publication date
6916</b><br>
6917   * Type: <b>date</b><br>
6918   * Path: <b>CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date</b><br>
6919   * </p>
6920   */
6921  @SearchParamDefinition(name="date", path="CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The capability statement publication date\r\n* [CodeSystem](codesystem.html): The code system publication date\r\n* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date\r\n* [ConceptMap](conceptmap.html): The concept map publication date\r\n* [GraphDefinition](graphdefinition.html): The graph definition publication date\r\n* [ImplementationGuide](implementationguide.html): The implementation guide publication date\r\n* [MessageDefinition](messagedefinition.html): The message definition publication date\r\n* [NamingSystem](namingsystem.html): The naming system publication date\r\n* [OperationDefinition](operationdefinition.html): The operation definition publication date\r\n* [SearchParameter](searchparameter.html): The search parameter publication date\r\n* [StructureDefinition](structuredefinition.html): The structure definition publication date\r\n* [StructureMap](structuremap.html): The structure map publication date\r\n* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date\r\n* [ValueSet](valueset.html): The value set publication date\r\n", type="date" )
6922  public static final String SP_DATE = "date";
6923 /**
6924   * <b>Fluent Client</b> search parameter constant for <b>date</b>
6925   * <p>
6926   * Description: <b>Multiple Resources: 
6927
6928* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
6929* [CodeSystem](codesystem.html): The code system publication date
6930* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
6931* [ConceptMap](conceptmap.html): The concept map publication date
6932* [GraphDefinition](graphdefinition.html): The graph definition publication date
6933* [ImplementationGuide](implementationguide.html): The implementation guide publication date
6934* [MessageDefinition](messagedefinition.html): The message definition publication date
6935* [NamingSystem](namingsystem.html): The naming system publication date
6936* [OperationDefinition](operationdefinition.html): The operation definition publication date
6937* [SearchParameter](searchparameter.html): The search parameter publication date
6938* [StructureDefinition](structuredefinition.html): The structure definition publication date
6939* [StructureMap](structuremap.html): The structure map publication date
6940* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
6941* [ValueSet](valueset.html): The value set publication date
6942</b><br>
6943   * Type: <b>date</b><br>
6944   * Path: <b>CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date</b><br>
6945   * </p>
6946   */
6947  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
6948
6949 /**
6950   * Search parameter: <b>description</b>
6951   * <p>
6952   * Description: <b>Multiple Resources: 
6953
6954* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
6955* [CodeSystem](codesystem.html): The description of the code system
6956* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
6957* [ConceptMap](conceptmap.html): The description of the concept map
6958* [GraphDefinition](graphdefinition.html): The description of the graph definition
6959* [ImplementationGuide](implementationguide.html): The description of the implementation guide
6960* [MessageDefinition](messagedefinition.html): The description of the message definition
6961* [NamingSystem](namingsystem.html): The description of the naming system
6962* [OperationDefinition](operationdefinition.html): The description of the operation definition
6963* [SearchParameter](searchparameter.html): The description of the search parameter
6964* [StructureDefinition](structuredefinition.html): The description of the structure definition
6965* [StructureMap](structuremap.html): The description of the structure map
6966* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
6967* [ValueSet](valueset.html): The description of the value set
6968</b><br>
6969   * Type: <b>string</b><br>
6970   * Path: <b>CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description</b><br>
6971   * </p>
6972   */
6973  @SearchParamDefinition(name="description", path="CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The description of the capability statement\r\n* [CodeSystem](codesystem.html): The description of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition\r\n* [ConceptMap](conceptmap.html): The description of the concept map\r\n* [GraphDefinition](graphdefinition.html): The description of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The description of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The description of the message definition\r\n* [NamingSystem](namingsystem.html): The description of the naming system\r\n* [OperationDefinition](operationdefinition.html): The description of the operation definition\r\n* [SearchParameter](searchparameter.html): The description of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The description of the structure definition\r\n* [StructureMap](structuremap.html): The description of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities\r\n* [ValueSet](valueset.html): The description of the value set\r\n", type="string" )
6974  public static final String SP_DESCRIPTION = "description";
6975 /**
6976   * <b>Fluent Client</b> search parameter constant for <b>description</b>
6977   * <p>
6978   * Description: <b>Multiple Resources: 
6979
6980* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
6981* [CodeSystem](codesystem.html): The description of the code system
6982* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
6983* [ConceptMap](conceptmap.html): The description of the concept map
6984* [GraphDefinition](graphdefinition.html): The description of the graph definition
6985* [ImplementationGuide](implementationguide.html): The description of the implementation guide
6986* [MessageDefinition](messagedefinition.html): The description of the message definition
6987* [NamingSystem](namingsystem.html): The description of the naming system
6988* [OperationDefinition](operationdefinition.html): The description of the operation definition
6989* [SearchParameter](searchparameter.html): The description of the search parameter
6990* [StructureDefinition](structuredefinition.html): The description of the structure definition
6991* [StructureMap](structuremap.html): The description of the structure map
6992* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
6993* [ValueSet](valueset.html): The description of the value set
6994</b><br>
6995   * Type: <b>string</b><br>
6996   * Path: <b>CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description</b><br>
6997   * </p>
6998   */
6999  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
7000
7001 /**
7002   * Search parameter: <b>identifier</b>
7003   * <p>
7004   * Description: <b>Multiple Resources: 
7005
7006* [CodeSystem](codesystem.html): External identifier for the code system
7007* [ConceptMap](conceptmap.html): External identifier for the concept map
7008* [MessageDefinition](messagedefinition.html): External identifier for the message definition
7009* [NamingSystem](namingsystem.html): External identifier for the naming system
7010* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
7011* [StructureMap](structuremap.html): External identifier for the structure map
7012* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
7013* [ValueSet](valueset.html): External identifier for the value set
7014</b><br>
7015   * Type: <b>token</b><br>
7016   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | NamingSystem.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier</b><br>
7017   * </p>
7018   */
7019  @SearchParamDefinition(name="identifier", path="CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | NamingSystem.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier", description="Multiple Resources: \r\n\r\n* [CodeSystem](codesystem.html): External identifier for the code system\r\n* [ConceptMap](conceptmap.html): External identifier for the concept map\r\n* [MessageDefinition](messagedefinition.html): External identifier for the message definition\r\n* [NamingSystem](namingsystem.html): External identifier for the naming system\r\n* [StructureDefinition](structuredefinition.html): External identifier for the structure definition\r\n* [StructureMap](structuremap.html): External identifier for the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities\r\n* [ValueSet](valueset.html): External identifier for the value set\r\n", type="token" )
7020  public static final String SP_IDENTIFIER = "identifier";
7021 /**
7022   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
7023   * <p>
7024   * Description: <b>Multiple Resources: 
7025
7026* [CodeSystem](codesystem.html): External identifier for the code system
7027* [ConceptMap](conceptmap.html): External identifier for the concept map
7028* [MessageDefinition](messagedefinition.html): External identifier for the message definition
7029* [NamingSystem](namingsystem.html): External identifier for the naming system
7030* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
7031* [StructureMap](structuremap.html): External identifier for the structure map
7032* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
7033* [ValueSet](valueset.html): External identifier for the value set
7034</b><br>
7035   * Type: <b>token</b><br>
7036   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | NamingSystem.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier</b><br>
7037   * </p>
7038   */
7039  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
7040
7041 /**
7042   * Search parameter: <b>jurisdiction</b>
7043   * <p>
7044   * Description: <b>Multiple Resources: 
7045
7046* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
7047* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
7048* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
7049* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
7050* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
7051* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
7052* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
7053* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
7054* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
7055* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
7056* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
7057* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
7058* [ValueSet](valueset.html): Intended jurisdiction for the value set
7059</b><br>
7060   * Type: <b>token</b><br>
7061   * Path: <b>CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction</b><br>
7062   * </p>
7063   */
7064  @SearchParamDefinition(name="jurisdiction", path="CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement\r\n* [CodeSystem](codesystem.html): Intended jurisdiction for the code system\r\n* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map\r\n* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition\r\n* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition\r\n* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system\r\n* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition\r\n* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter\r\n* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition\r\n* [StructureMap](structuremap.html): Intended jurisdiction for the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities\r\n* [ValueSet](valueset.html): Intended jurisdiction for the value set\r\n", type="token" )
7065  public static final String SP_JURISDICTION = "jurisdiction";
7066 /**
7067   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
7068   * <p>
7069   * Description: <b>Multiple Resources: 
7070
7071* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
7072* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
7073* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
7074* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
7075* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
7076* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
7077* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
7078* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
7079* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
7080* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
7081* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
7082* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
7083* [ValueSet](valueset.html): Intended jurisdiction for the value set
7084</b><br>
7085   * Type: <b>token</b><br>
7086   * Path: <b>CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction</b><br>
7087   * </p>
7088   */
7089  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
7090
7091 /**
7092   * Search parameter: <b>name</b>
7093   * <p>
7094   * Description: <b>Multiple Resources: 
7095
7096* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
7097* [CodeSystem](codesystem.html): Computationally friendly name of the code system
7098* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
7099* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
7100* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
7101* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
7102* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
7103* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
7104* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
7105* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
7106* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
7107* [StructureMap](structuremap.html): Computationally friendly name of the structure map
7108* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
7109* [ValueSet](valueset.html): Computationally friendly name of the value set
7110</b><br>
7111   * Type: <b>string</b><br>
7112   * Path: <b>CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name</b><br>
7113   * </p>
7114   */
7115  @SearchParamDefinition(name="name", path="CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement\r\n* [CodeSystem](codesystem.html): Computationally friendly name of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition\r\n* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map\r\n* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition\r\n* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system\r\n* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition\r\n* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition\r\n* [StructureMap](structuremap.html): Computationally friendly name of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities\r\n* [ValueSet](valueset.html): Computationally friendly name of the value set\r\n", type="string" )
7116  public static final String SP_NAME = "name";
7117 /**
7118   * <b>Fluent Client</b> search parameter constant for <b>name</b>
7119   * <p>
7120   * Description: <b>Multiple Resources: 
7121
7122* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
7123* [CodeSystem](codesystem.html): Computationally friendly name of the code system
7124* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
7125* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
7126* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
7127* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
7128* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
7129* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
7130* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
7131* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
7132* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
7133* [StructureMap](structuremap.html): Computationally friendly name of the structure map
7134* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
7135* [ValueSet](valueset.html): Computationally friendly name of the value set
7136</b><br>
7137   * Type: <b>string</b><br>
7138   * Path: <b>CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name</b><br>
7139   * </p>
7140   */
7141  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
7142
7143 /**
7144   * Search parameter: <b>publisher</b>
7145   * <p>
7146   * Description: <b>Multiple Resources: 
7147
7148* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
7149* [CodeSystem](codesystem.html): Name of the publisher of the code system
7150* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
7151* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
7152* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
7153* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
7154* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
7155* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
7156* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
7157* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
7158* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
7159* [StructureMap](structuremap.html): Name of the publisher of the structure map
7160* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
7161* [ValueSet](valueset.html): Name of the publisher of the value set
7162</b><br>
7163   * Type: <b>string</b><br>
7164   * Path: <b>CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher</b><br>
7165   * </p>
7166   */
7167  @SearchParamDefinition(name="publisher", path="CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement\r\n* [CodeSystem](codesystem.html): Name of the publisher of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition\r\n* [ConceptMap](conceptmap.html): Name of the publisher of the concept map\r\n* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition\r\n* [NamingSystem](namingsystem.html): Name of the publisher of the naming system\r\n* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition\r\n* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition\r\n* [StructureMap](structuremap.html): Name of the publisher of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities\r\n* [ValueSet](valueset.html): Name of the publisher of the value set\r\n", type="string" )
7168  public static final String SP_PUBLISHER = "publisher";
7169 /**
7170   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
7171   * <p>
7172   * Description: <b>Multiple Resources: 
7173
7174* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
7175* [CodeSystem](codesystem.html): Name of the publisher of the code system
7176* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
7177* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
7178* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
7179* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
7180* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
7181* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
7182* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
7183* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
7184* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
7185* [StructureMap](structuremap.html): Name of the publisher of the structure map
7186* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
7187* [ValueSet](valueset.html): Name of the publisher of the value set
7188</b><br>
7189   * Type: <b>string</b><br>
7190   * Path: <b>CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher</b><br>
7191   * </p>
7192   */
7193  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
7194
7195 /**
7196   * Search parameter: <b>status</b>
7197   * <p>
7198   * Description: <b>Multiple Resources: 
7199
7200* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
7201* [CodeSystem](codesystem.html): The current status of the code system
7202* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
7203* [ConceptMap](conceptmap.html): The current status of the concept map
7204* [GraphDefinition](graphdefinition.html): The current status of the graph definition
7205* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
7206* [MessageDefinition](messagedefinition.html): The current status of the message definition
7207* [NamingSystem](namingsystem.html): The current status of the naming system
7208* [OperationDefinition](operationdefinition.html): The current status of the operation definition
7209* [SearchParameter](searchparameter.html): The current status of the search parameter
7210* [StructureDefinition](structuredefinition.html): The current status of the structure definition
7211* [StructureMap](structuremap.html): The current status of the structure map
7212* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
7213* [ValueSet](valueset.html): The current status of the value set
7214</b><br>
7215   * Type: <b>token</b><br>
7216   * Path: <b>CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status</b><br>
7217   * </p>
7218   */
7219  @SearchParamDefinition(name="status", path="CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement\r\n* [CodeSystem](codesystem.html): The current status of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition\r\n* [ConceptMap](conceptmap.html): The current status of the concept map\r\n* [GraphDefinition](graphdefinition.html): The current status of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The current status of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The current status of the message definition\r\n* [NamingSystem](namingsystem.html): The current status of the naming system\r\n* [OperationDefinition](operationdefinition.html): The current status of the operation definition\r\n* [SearchParameter](searchparameter.html): The current status of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The current status of the structure definition\r\n* [StructureMap](structuremap.html): The current status of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities\r\n* [ValueSet](valueset.html): The current status of the value set\r\n", type="token" )
7220  public static final String SP_STATUS = "status";
7221 /**
7222   * <b>Fluent Client</b> search parameter constant for <b>status</b>
7223   * <p>
7224   * Description: <b>Multiple Resources: 
7225
7226* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
7227* [CodeSystem](codesystem.html): The current status of the code system
7228* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
7229* [ConceptMap](conceptmap.html): The current status of the concept map
7230* [GraphDefinition](graphdefinition.html): The current status of the graph definition
7231* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
7232* [MessageDefinition](messagedefinition.html): The current status of the message definition
7233* [NamingSystem](namingsystem.html): The current status of the naming system
7234* [OperationDefinition](operationdefinition.html): The current status of the operation definition
7235* [SearchParameter](searchparameter.html): The current status of the search parameter
7236* [StructureDefinition](structuredefinition.html): The current status of the structure definition
7237* [StructureMap](structuremap.html): The current status of the structure map
7238* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
7239* [ValueSet](valueset.html): The current status of the value set
7240</b><br>
7241   * Type: <b>token</b><br>
7242   * Path: <b>CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status</b><br>
7243   * </p>
7244   */
7245  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
7246
7247 /**
7248   * Search parameter: <b>title</b>
7249   * <p>
7250   * Description: <b>Multiple Resources: 
7251
7252* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
7253* [CodeSystem](codesystem.html): The human-friendly name of the code system
7254* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
7255* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
7256* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
7257* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
7258* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
7259* [StructureMap](structuremap.html): The human-friendly name of the structure map
7260* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
7261* [ValueSet](valueset.html): The human-friendly name of the value set
7262</b><br>
7263   * Type: <b>string</b><br>
7264   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
7265   * </p>
7266   */
7267  @SearchParamDefinition(name="title", path="CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement\r\n* [CodeSystem](codesystem.html): The human-friendly name of the code system\r\n* [ConceptMap](conceptmap.html): The human-friendly name of the concept map\r\n* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition\r\n* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition\r\n* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition\r\n* [StructureMap](structuremap.html): The human-friendly name of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities\r\n* [ValueSet](valueset.html): The human-friendly name of the value set\r\n", type="string" )
7268  public static final String SP_TITLE = "title";
7269 /**
7270   * <b>Fluent Client</b> search parameter constant for <b>title</b>
7271   * <p>
7272   * Description: <b>Multiple Resources: 
7273
7274* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
7275* [CodeSystem](codesystem.html): The human-friendly name of the code system
7276* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
7277* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
7278* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
7279* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
7280* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
7281* [StructureMap](structuremap.html): The human-friendly name of the structure map
7282* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
7283* [ValueSet](valueset.html): The human-friendly name of the value set
7284</b><br>
7285   * Type: <b>string</b><br>
7286   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
7287   * </p>
7288   */
7289  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
7290
7291 /**
7292   * Search parameter: <b>url</b>
7293   * <p>
7294   * Description: <b>Multiple Resources: 
7295
7296* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
7297* [CodeSystem](codesystem.html): The uri that identifies the code system
7298* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
7299* [ConceptMap](conceptmap.html): The URI that identifies the concept map
7300* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
7301* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
7302* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
7303* [NamingSystem](namingsystem.html): The uri that identifies the naming system
7304* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
7305* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
7306* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
7307* [StructureMap](structuremap.html): The uri that identifies the structure map
7308* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
7309* [ValueSet](valueset.html): The uri that identifies the value set
7310</b><br>
7311   * Type: <b>uri</b><br>
7312   * Path: <b>CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | NamingSystem.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url</b><br>
7313   * </p>
7314   */
7315  @SearchParamDefinition(name="url", path="CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | NamingSystem.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement\r\n* [CodeSystem](codesystem.html): The uri that identifies the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition\r\n* [ConceptMap](conceptmap.html): The URI that identifies the concept map\r\n* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition\r\n* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition\r\n* [NamingSystem](namingsystem.html): The uri that identifies the naming system\r\n* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition\r\n* [SearchParameter](searchparameter.html): The uri that identifies the search parameter\r\n* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition\r\n* [StructureMap](structuremap.html): The uri that identifies the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities\r\n* [ValueSet](valueset.html): The uri that identifies the value set\r\n", type="uri" )
7316  public static final String SP_URL = "url";
7317 /**
7318   * <b>Fluent Client</b> search parameter constant for <b>url</b>
7319   * <p>
7320   * Description: <b>Multiple Resources: 
7321
7322* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
7323* [CodeSystem](codesystem.html): The uri that identifies the code system
7324* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
7325* [ConceptMap](conceptmap.html): The URI that identifies the concept map
7326* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
7327* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
7328* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
7329* [NamingSystem](namingsystem.html): The uri that identifies the naming system
7330* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
7331* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
7332* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
7333* [StructureMap](structuremap.html): The uri that identifies the structure map
7334* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
7335* [ValueSet](valueset.html): The uri that identifies the value set
7336</b><br>
7337   * Type: <b>uri</b><br>
7338   * Path: <b>CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | NamingSystem.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url</b><br>
7339   * </p>
7340   */
7341  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
7342
7343 /**
7344   * Search parameter: <b>version</b>
7345   * <p>
7346   * Description: <b>Multiple Resources: 
7347
7348* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
7349* [CodeSystem](codesystem.html): The business version of the code system
7350* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
7351* [ConceptMap](conceptmap.html): The business version of the concept map
7352* [GraphDefinition](graphdefinition.html): The business version of the graph definition
7353* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
7354* [MessageDefinition](messagedefinition.html): The business version of the message definition
7355* [NamingSystem](namingsystem.html): The business version of the naming system
7356* [OperationDefinition](operationdefinition.html): The business version of the operation definition
7357* [SearchParameter](searchparameter.html): The business version of the search parameter
7358* [StructureDefinition](structuredefinition.html): The business version of the structure definition
7359* [StructureMap](structuremap.html): The business version of the structure map
7360* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
7361* [ValueSet](valueset.html): The business version of the value set
7362</b><br>
7363   * Type: <b>token</b><br>
7364   * Path: <b>CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version</b><br>
7365   * </p>
7366   */
7367  @SearchParamDefinition(name="version", path="CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement\r\n* [CodeSystem](codesystem.html): The business version of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition\r\n* [ConceptMap](conceptmap.html): The business version of the concept map\r\n* [GraphDefinition](graphdefinition.html): The business version of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The business version of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The business version of the message definition\r\n* [NamingSystem](namingsystem.html): The business version of the naming system\r\n* [OperationDefinition](operationdefinition.html): The business version of the operation definition\r\n* [SearchParameter](searchparameter.html): The business version of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The business version of the structure definition\r\n* [StructureMap](structuremap.html): The business version of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities\r\n* [ValueSet](valueset.html): The business version of the value set\r\n", type="token" )
7368  public static final String SP_VERSION = "version";
7369 /**
7370   * <b>Fluent Client</b> search parameter constant for <b>version</b>
7371   * <p>
7372   * Description: <b>Multiple Resources: 
7373
7374* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
7375* [CodeSystem](codesystem.html): The business version of the code system
7376* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
7377* [ConceptMap](conceptmap.html): The business version of the concept map
7378* [GraphDefinition](graphdefinition.html): The business version of the graph definition
7379* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
7380* [MessageDefinition](messagedefinition.html): The business version of the message definition
7381* [NamingSystem](namingsystem.html): The business version of the naming system
7382* [OperationDefinition](operationdefinition.html): The business version of the operation definition
7383* [SearchParameter](searchparameter.html): The business version of the search parameter
7384* [StructureDefinition](structuredefinition.html): The business version of the structure definition
7385* [StructureMap](structuremap.html): The business version of the structure map
7386* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
7387* [ValueSet](valueset.html): The business version of the value set
7388</b><br>
7389   * Type: <b>token</b><br>
7390   * Path: <b>CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version</b><br>
7391   * </p>
7392   */
7393  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
7394
7395// Manual code (from Configuration.txt):
7396public String toString() {
7397    return StructureMapUtilities.render(this);
7398  }
7399// end addition
7400
7401}
7402