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 Fri, Jul 15, 2022 11:20+1000 for FHIR v5.0.0-snapshot2
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 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 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     * 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.
5057     */
5058    @Child(name = "name", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=true)
5059    @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." )
5060    protected StringType name;
5061
5062    /**
5063     * A short, descriptive, user-friendly title for the structure map.
5064     */
5065    @Child(name = "title", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
5066    @Description(shortDefinition="Name for this structure map (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the structure map." )
5067    protected StringType title;
5068
5069    /**
5070     * The status of this structure map. Enables tracking the life-cycle of the content.
5071     */
5072    @Child(name = "status", type = {CodeType.class}, order=5, min=1, max=1, modifier=true, summary=true)
5073    @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this structure map. Enables tracking the life-cycle of the content." )
5074    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status")
5075    protected Enumeration<PublicationStatus> status;
5076
5077    /**
5078     * 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.
5079     */
5080    @Child(name = "experimental", type = {BooleanType.class}, order=6, min=0, max=1, modifier=false, summary=true)
5081    @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." )
5082    protected BooleanType experimental;
5083
5084    /**
5085     * 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.
5086     */
5087    @Child(name = "date", type = {DateTimeType.class}, order=7, min=0, max=1, modifier=false, summary=true)
5088    @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." )
5089    protected DateTimeType date;
5090
5091    /**
5092     * The name of the organization or individual that published the structure map.
5093     */
5094    @Child(name = "publisher", type = {StringType.class}, order=8, min=0, max=1, modifier=false, summary=true)
5095    @Description(shortDefinition="Name of the publisher (organization or individual)", formalDefinition="The name of the organization or individual that published the structure map." )
5096    protected StringType publisher;
5097
5098    /**
5099     * Contact details to assist a user in finding and communicating with the publisher.
5100     */
5101    @Child(name = "contact", type = {ContactDetail.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5102    @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." )
5103    protected List<ContactDetail> contact;
5104
5105    /**
5106     * A free text natural language description of the structure map from a consumer's perspective.
5107     */
5108    @Child(name = "description", type = {MarkdownType.class}, order=10, min=0, max=1, modifier=false, summary=false)
5109    @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." )
5110    protected MarkdownType description;
5111
5112    /**
5113     * 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.
5114     */
5115    @Child(name = "useContext", type = {UsageContext.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5116    @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." )
5117    protected List<UsageContext> useContext;
5118
5119    /**
5120     * A legal or geographic region in which the structure map is intended to be used.
5121     */
5122    @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5123    @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." )
5124    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction")
5125    protected List<CodeableConcept> jurisdiction;
5126
5127    /**
5128     * Explanation of why this structure map is needed and why it has been designed as it has.
5129     */
5130    @Child(name = "purpose", type = {MarkdownType.class}, order=13, min=0, max=1, modifier=false, summary=false)
5131    @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." )
5132    protected MarkdownType purpose;
5133
5134    /**
5135     * 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.
5136     */
5137    @Child(name = "copyright", type = {MarkdownType.class}, order=14, min=0, max=1, modifier=false, summary=false)
5138    @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." )
5139    protected MarkdownType copyright;
5140
5141    /**
5142     * A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced.
5143     */
5144    @Child(name = "structure", type = {}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5145    @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." )
5146    protected List<StructureMapStructureComponent> structure;
5147
5148    /**
5149     * Other maps used by this map (canonical URLs).
5150     */
5151    @Child(name = "import", type = {CanonicalType.class}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5152    @Description(shortDefinition="Other maps used by this map (canonical URLs)", formalDefinition="Other maps used by this map (canonical URLs)." )
5153    protected List<CanonicalType> import_;
5154
5155    /**
5156     * Organizes the mapping into manageable chunks for human review/ease of maintenance.
5157     */
5158    @Child(name = "group", type = {}, order=17, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5159    @Description(shortDefinition="Named sections for reader convenience", formalDefinition="Organizes the mapping into manageable chunks for human review/ease of maintenance." )
5160    protected List<StructureMapGroupComponent> group;
5161
5162    private static final long serialVersionUID = 573973893L;
5163
5164  /**
5165   * Constructor
5166   */
5167    public StructureMap() {
5168      super();
5169    }
5170
5171  /**
5172   * Constructor
5173   */
5174    public StructureMap(String url, String name, PublicationStatus status, StructureMapGroupComponent group) {
5175      super();
5176      this.setUrl(url);
5177      this.setName(name);
5178      this.setStatus(status);
5179      this.addGroup(group);
5180    }
5181
5182    /**
5183     * @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 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
5184     */
5185    public UriType getUrlElement() { 
5186      if (this.url == null)
5187        if (Configuration.errorOnAutoCreate())
5188          throw new Error("Attempt to auto-create StructureMap.url");
5189        else if (Configuration.doAutoCreate())
5190          this.url = new UriType(); // bb
5191      return this.url;
5192    }
5193
5194    public boolean hasUrlElement() { 
5195      return this.url != null && !this.url.isEmpty();
5196    }
5197
5198    public boolean hasUrl() { 
5199      return this.url != null && !this.url.isEmpty();
5200    }
5201
5202    /**
5203     * @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 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
5204     */
5205    public StructureMap setUrlElement(UriType value) { 
5206      this.url = value;
5207      return this;
5208    }
5209
5210    /**
5211     * @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 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.
5212     */
5213    public String getUrl() { 
5214      return this.url == null ? null : this.url.getValue();
5215    }
5216
5217    /**
5218     * @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 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.
5219     */
5220    public StructureMap setUrl(String value) { 
5221        if (this.url == null)
5222          this.url = new UriType();
5223        this.url.setValue(value);
5224      return this;
5225    }
5226
5227    /**
5228     * @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.)
5229     */
5230    public List<Identifier> getIdentifier() { 
5231      if (this.identifier == null)
5232        this.identifier = new ArrayList<Identifier>();
5233      return this.identifier;
5234    }
5235
5236    /**
5237     * @return Returns a reference to <code>this</code> for easy method chaining
5238     */
5239    public StructureMap setIdentifier(List<Identifier> theIdentifier) { 
5240      this.identifier = theIdentifier;
5241      return this;
5242    }
5243
5244    public boolean hasIdentifier() { 
5245      if (this.identifier == null)
5246        return false;
5247      for (Identifier item : this.identifier)
5248        if (!item.isEmpty())
5249          return true;
5250      return false;
5251    }
5252
5253    public Identifier addIdentifier() { //3
5254      Identifier t = new Identifier();
5255      if (this.identifier == null)
5256        this.identifier = new ArrayList<Identifier>();
5257      this.identifier.add(t);
5258      return t;
5259    }
5260
5261    public StructureMap addIdentifier(Identifier t) { //3
5262      if (t == null)
5263        return this;
5264      if (this.identifier == null)
5265        this.identifier = new ArrayList<Identifier>();
5266      this.identifier.add(t);
5267      return this;
5268    }
5269
5270    /**
5271     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
5272     */
5273    public Identifier getIdentifierFirstRep() { 
5274      if (getIdentifier().isEmpty()) {
5275        addIdentifier();
5276      }
5277      return getIdentifier().get(0);
5278    }
5279
5280    /**
5281     * @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
5282     */
5283    public StringType getVersionElement() { 
5284      if (this.version == null)
5285        if (Configuration.errorOnAutoCreate())
5286          throw new Error("Attempt to auto-create StructureMap.version");
5287        else if (Configuration.doAutoCreate())
5288          this.version = new StringType(); // bb
5289      return this.version;
5290    }
5291
5292    public boolean hasVersionElement() { 
5293      return this.version != null && !this.version.isEmpty();
5294    }
5295
5296    public boolean hasVersion() { 
5297      return this.version != null && !this.version.isEmpty();
5298    }
5299
5300    /**
5301     * @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
5302     */
5303    public StructureMap setVersionElement(StringType value) { 
5304      this.version = value;
5305      return this;
5306    }
5307
5308    /**
5309     * @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.
5310     */
5311    public String getVersion() { 
5312      return this.version == null ? null : this.version.getValue();
5313    }
5314
5315    /**
5316     * @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.
5317     */
5318    public StructureMap setVersion(String value) { 
5319      if (Utilities.noString(value))
5320        this.version = null;
5321      else {
5322        if (this.version == null)
5323          this.version = new StringType();
5324        this.version.setValue(value);
5325      }
5326      return this;
5327    }
5328
5329    /**
5330     * @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
5331     */
5332    public StringType getNameElement() { 
5333      if (this.name == null)
5334        if (Configuration.errorOnAutoCreate())
5335          throw new Error("Attempt to auto-create StructureMap.name");
5336        else if (Configuration.doAutoCreate())
5337          this.name = new StringType(); // bb
5338      return this.name;
5339    }
5340
5341    public boolean hasNameElement() { 
5342      return this.name != null && !this.name.isEmpty();
5343    }
5344
5345    public boolean hasName() { 
5346      return this.name != null && !this.name.isEmpty();
5347    }
5348
5349    /**
5350     * @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
5351     */
5352    public StructureMap setNameElement(StringType value) { 
5353      this.name = value;
5354      return this;
5355    }
5356
5357    /**
5358     * @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.
5359     */
5360    public String getName() { 
5361      return this.name == null ? null : this.name.getValue();
5362    }
5363
5364    /**
5365     * @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.
5366     */
5367    public StructureMap setName(String value) { 
5368        if (this.name == null)
5369          this.name = new StringType();
5370        this.name.setValue(value);
5371      return this;
5372    }
5373
5374    /**
5375     * @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
5376     */
5377    public StringType getTitleElement() { 
5378      if (this.title == null)
5379        if (Configuration.errorOnAutoCreate())
5380          throw new Error("Attempt to auto-create StructureMap.title");
5381        else if (Configuration.doAutoCreate())
5382          this.title = new StringType(); // bb
5383      return this.title;
5384    }
5385
5386    public boolean hasTitleElement() { 
5387      return this.title != null && !this.title.isEmpty();
5388    }
5389
5390    public boolean hasTitle() { 
5391      return this.title != null && !this.title.isEmpty();
5392    }
5393
5394    /**
5395     * @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
5396     */
5397    public StructureMap setTitleElement(StringType value) { 
5398      this.title = value;
5399      return this;
5400    }
5401
5402    /**
5403     * @return A short, descriptive, user-friendly title for the structure map.
5404     */
5405    public String getTitle() { 
5406      return this.title == null ? null : this.title.getValue();
5407    }
5408
5409    /**
5410     * @param value A short, descriptive, user-friendly title for the structure map.
5411     */
5412    public StructureMap setTitle(String value) { 
5413      if (Utilities.noString(value))
5414        this.title = null;
5415      else {
5416        if (this.title == null)
5417          this.title = new StringType();
5418        this.title.setValue(value);
5419      }
5420      return this;
5421    }
5422
5423    /**
5424     * @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
5425     */
5426    public Enumeration<PublicationStatus> getStatusElement() { 
5427      if (this.status == null)
5428        if (Configuration.errorOnAutoCreate())
5429          throw new Error("Attempt to auto-create StructureMap.status");
5430        else if (Configuration.doAutoCreate())
5431          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
5432      return this.status;
5433    }
5434
5435    public boolean hasStatusElement() { 
5436      return this.status != null && !this.status.isEmpty();
5437    }
5438
5439    public boolean hasStatus() { 
5440      return this.status != null && !this.status.isEmpty();
5441    }
5442
5443    /**
5444     * @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
5445     */
5446    public StructureMap setStatusElement(Enumeration<PublicationStatus> value) { 
5447      this.status = value;
5448      return this;
5449    }
5450
5451    /**
5452     * @return The status of this structure map. Enables tracking the life-cycle of the content.
5453     */
5454    public PublicationStatus getStatus() { 
5455      return this.status == null ? null : this.status.getValue();
5456    }
5457
5458    /**
5459     * @param value The status of this structure map. Enables tracking the life-cycle of the content.
5460     */
5461    public StructureMap setStatus(PublicationStatus value) { 
5462        if (this.status == null)
5463          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
5464        this.status.setValue(value);
5465      return this;
5466    }
5467
5468    /**
5469     * @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
5470     */
5471    public BooleanType getExperimentalElement() { 
5472      if (this.experimental == null)
5473        if (Configuration.errorOnAutoCreate())
5474          throw new Error("Attempt to auto-create StructureMap.experimental");
5475        else if (Configuration.doAutoCreate())
5476          this.experimental = new BooleanType(); // bb
5477      return this.experimental;
5478    }
5479
5480    public boolean hasExperimentalElement() { 
5481      return this.experimental != null && !this.experimental.isEmpty();
5482    }
5483
5484    public boolean hasExperimental() { 
5485      return this.experimental != null && !this.experimental.isEmpty();
5486    }
5487
5488    /**
5489     * @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
5490     */
5491    public StructureMap setExperimentalElement(BooleanType value) { 
5492      this.experimental = value;
5493      return this;
5494    }
5495
5496    /**
5497     * @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.
5498     */
5499    public boolean getExperimental() { 
5500      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
5501    }
5502
5503    /**
5504     * @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.
5505     */
5506    public StructureMap setExperimental(boolean value) { 
5507        if (this.experimental == null)
5508          this.experimental = new BooleanType();
5509        this.experimental.setValue(value);
5510      return this;
5511    }
5512
5513    /**
5514     * @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
5515     */
5516    public DateTimeType getDateElement() { 
5517      if (this.date == null)
5518        if (Configuration.errorOnAutoCreate())
5519          throw new Error("Attempt to auto-create StructureMap.date");
5520        else if (Configuration.doAutoCreate())
5521          this.date = new DateTimeType(); // bb
5522      return this.date;
5523    }
5524
5525    public boolean hasDateElement() { 
5526      return this.date != null && !this.date.isEmpty();
5527    }
5528
5529    public boolean hasDate() { 
5530      return this.date != null && !this.date.isEmpty();
5531    }
5532
5533    /**
5534     * @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
5535     */
5536    public StructureMap setDateElement(DateTimeType value) { 
5537      this.date = value;
5538      return this;
5539    }
5540
5541    /**
5542     * @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.
5543     */
5544    public Date getDate() { 
5545      return this.date == null ? null : this.date.getValue();
5546    }
5547
5548    /**
5549     * @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.
5550     */
5551    public StructureMap setDate(Date value) { 
5552      if (value == null)
5553        this.date = null;
5554      else {
5555        if (this.date == null)
5556          this.date = new DateTimeType();
5557        this.date.setValue(value);
5558      }
5559      return this;
5560    }
5561
5562    /**
5563     * @return {@link #publisher} (The name of the organization or individual that published the structure map.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
5564     */
5565    public StringType getPublisherElement() { 
5566      if (this.publisher == null)
5567        if (Configuration.errorOnAutoCreate())
5568          throw new Error("Attempt to auto-create StructureMap.publisher");
5569        else if (Configuration.doAutoCreate())
5570          this.publisher = new StringType(); // bb
5571      return this.publisher;
5572    }
5573
5574    public boolean hasPublisherElement() { 
5575      return this.publisher != null && !this.publisher.isEmpty();
5576    }
5577
5578    public boolean hasPublisher() { 
5579      return this.publisher != null && !this.publisher.isEmpty();
5580    }
5581
5582    /**
5583     * @param value {@link #publisher} (The name of the organization or individual that published the structure map.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
5584     */
5585    public StructureMap setPublisherElement(StringType value) { 
5586      this.publisher = value;
5587      return this;
5588    }
5589
5590    /**
5591     * @return The name of the organization or individual that published the structure map.
5592     */
5593    public String getPublisher() { 
5594      return this.publisher == null ? null : this.publisher.getValue();
5595    }
5596
5597    /**
5598     * @param value The name of the organization or individual that published the structure map.
5599     */
5600    public StructureMap setPublisher(String value) { 
5601      if (Utilities.noString(value))
5602        this.publisher = null;
5603      else {
5604        if (this.publisher == null)
5605          this.publisher = new StringType();
5606        this.publisher.setValue(value);
5607      }
5608      return this;
5609    }
5610
5611    /**
5612     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
5613     */
5614    public List<ContactDetail> getContact() { 
5615      if (this.contact == null)
5616        this.contact = new ArrayList<ContactDetail>();
5617      return this.contact;
5618    }
5619
5620    /**
5621     * @return Returns a reference to <code>this</code> for easy method chaining
5622     */
5623    public StructureMap setContact(List<ContactDetail> theContact) { 
5624      this.contact = theContact;
5625      return this;
5626    }
5627
5628    public boolean hasContact() { 
5629      if (this.contact == null)
5630        return false;
5631      for (ContactDetail item : this.contact)
5632        if (!item.isEmpty())
5633          return true;
5634      return false;
5635    }
5636
5637    public ContactDetail addContact() { //3
5638      ContactDetail t = new ContactDetail();
5639      if (this.contact == null)
5640        this.contact = new ArrayList<ContactDetail>();
5641      this.contact.add(t);
5642      return t;
5643    }
5644
5645    public StructureMap addContact(ContactDetail t) { //3
5646      if (t == null)
5647        return this;
5648      if (this.contact == null)
5649        this.contact = new ArrayList<ContactDetail>();
5650      this.contact.add(t);
5651      return this;
5652    }
5653
5654    /**
5655     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
5656     */
5657    public ContactDetail getContactFirstRep() { 
5658      if (getContact().isEmpty()) {
5659        addContact();
5660      }
5661      return getContact().get(0);
5662    }
5663
5664    /**
5665     * @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
5666     */
5667    public MarkdownType getDescriptionElement() { 
5668      if (this.description == null)
5669        if (Configuration.errorOnAutoCreate())
5670          throw new Error("Attempt to auto-create StructureMap.description");
5671        else if (Configuration.doAutoCreate())
5672          this.description = new MarkdownType(); // bb
5673      return this.description;
5674    }
5675
5676    public boolean hasDescriptionElement() { 
5677      return this.description != null && !this.description.isEmpty();
5678    }
5679
5680    public boolean hasDescription() { 
5681      return this.description != null && !this.description.isEmpty();
5682    }
5683
5684    /**
5685     * @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
5686     */
5687    public StructureMap setDescriptionElement(MarkdownType value) { 
5688      this.description = value;
5689      return this;
5690    }
5691
5692    /**
5693     * @return A free text natural language description of the structure map from a consumer's perspective.
5694     */
5695    public String getDescription() { 
5696      return this.description == null ? null : this.description.getValue();
5697    }
5698
5699    /**
5700     * @param value A free text natural language description of the structure map from a consumer's perspective.
5701     */
5702    public StructureMap setDescription(String value) { 
5703      if (value == null)
5704        this.description = null;
5705      else {
5706        if (this.description == null)
5707          this.description = new MarkdownType();
5708        this.description.setValue(value);
5709      }
5710      return this;
5711    }
5712
5713    /**
5714     * @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.)
5715     */
5716    public List<UsageContext> getUseContext() { 
5717      if (this.useContext == null)
5718        this.useContext = new ArrayList<UsageContext>();
5719      return this.useContext;
5720    }
5721
5722    /**
5723     * @return Returns a reference to <code>this</code> for easy method chaining
5724     */
5725    public StructureMap setUseContext(List<UsageContext> theUseContext) { 
5726      this.useContext = theUseContext;
5727      return this;
5728    }
5729
5730    public boolean hasUseContext() { 
5731      if (this.useContext == null)
5732        return false;
5733      for (UsageContext item : this.useContext)
5734        if (!item.isEmpty())
5735          return true;
5736      return false;
5737    }
5738
5739    public UsageContext addUseContext() { //3
5740      UsageContext t = new UsageContext();
5741      if (this.useContext == null)
5742        this.useContext = new ArrayList<UsageContext>();
5743      this.useContext.add(t);
5744      return t;
5745    }
5746
5747    public StructureMap addUseContext(UsageContext t) { //3
5748      if (t == null)
5749        return this;
5750      if (this.useContext == null)
5751        this.useContext = new ArrayList<UsageContext>();
5752      this.useContext.add(t);
5753      return this;
5754    }
5755
5756    /**
5757     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3}
5758     */
5759    public UsageContext getUseContextFirstRep() { 
5760      if (getUseContext().isEmpty()) {
5761        addUseContext();
5762      }
5763      return getUseContext().get(0);
5764    }
5765
5766    /**
5767     * @return {@link #jurisdiction} (A legal or geographic region in which the structure map is intended to be used.)
5768     */
5769    public List<CodeableConcept> getJurisdiction() { 
5770      if (this.jurisdiction == null)
5771        this.jurisdiction = new ArrayList<CodeableConcept>();
5772      return this.jurisdiction;
5773    }
5774
5775    /**
5776     * @return Returns a reference to <code>this</code> for easy method chaining
5777     */
5778    public StructureMap setJurisdiction(List<CodeableConcept> theJurisdiction) { 
5779      this.jurisdiction = theJurisdiction;
5780      return this;
5781    }
5782
5783    public boolean hasJurisdiction() { 
5784      if (this.jurisdiction == null)
5785        return false;
5786      for (CodeableConcept item : this.jurisdiction)
5787        if (!item.isEmpty())
5788          return true;
5789      return false;
5790    }
5791
5792    public CodeableConcept addJurisdiction() { //3
5793      CodeableConcept t = new CodeableConcept();
5794      if (this.jurisdiction == null)
5795        this.jurisdiction = new ArrayList<CodeableConcept>();
5796      this.jurisdiction.add(t);
5797      return t;
5798    }
5799
5800    public StructureMap addJurisdiction(CodeableConcept t) { //3
5801      if (t == null)
5802        return this;
5803      if (this.jurisdiction == null)
5804        this.jurisdiction = new ArrayList<CodeableConcept>();
5805      this.jurisdiction.add(t);
5806      return this;
5807    }
5808
5809    /**
5810     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3}
5811     */
5812    public CodeableConcept getJurisdictionFirstRep() { 
5813      if (getJurisdiction().isEmpty()) {
5814        addJurisdiction();
5815      }
5816      return getJurisdiction().get(0);
5817    }
5818
5819    /**
5820     * @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
5821     */
5822    public MarkdownType getPurposeElement() { 
5823      if (this.purpose == null)
5824        if (Configuration.errorOnAutoCreate())
5825          throw new Error("Attempt to auto-create StructureMap.purpose");
5826        else if (Configuration.doAutoCreate())
5827          this.purpose = new MarkdownType(); // bb
5828      return this.purpose;
5829    }
5830
5831    public boolean hasPurposeElement() { 
5832      return this.purpose != null && !this.purpose.isEmpty();
5833    }
5834
5835    public boolean hasPurpose() { 
5836      return this.purpose != null && !this.purpose.isEmpty();
5837    }
5838
5839    /**
5840     * @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
5841     */
5842    public StructureMap setPurposeElement(MarkdownType value) { 
5843      this.purpose = value;
5844      return this;
5845    }
5846
5847    /**
5848     * @return Explanation of why this structure map is needed and why it has been designed as it has.
5849     */
5850    public String getPurpose() { 
5851      return this.purpose == null ? null : this.purpose.getValue();
5852    }
5853
5854    /**
5855     * @param value Explanation of why this structure map is needed and why it has been designed as it has.
5856     */
5857    public StructureMap setPurpose(String value) { 
5858      if (value == null)
5859        this.purpose = null;
5860      else {
5861        if (this.purpose == null)
5862          this.purpose = new MarkdownType();
5863        this.purpose.setValue(value);
5864      }
5865      return this;
5866    }
5867
5868    /**
5869     * @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
5870     */
5871    public MarkdownType getCopyrightElement() { 
5872      if (this.copyright == null)
5873        if (Configuration.errorOnAutoCreate())
5874          throw new Error("Attempt to auto-create StructureMap.copyright");
5875        else if (Configuration.doAutoCreate())
5876          this.copyright = new MarkdownType(); // bb
5877      return this.copyright;
5878    }
5879
5880    public boolean hasCopyrightElement() { 
5881      return this.copyright != null && !this.copyright.isEmpty();
5882    }
5883
5884    public boolean hasCopyright() { 
5885      return this.copyright != null && !this.copyright.isEmpty();
5886    }
5887
5888    /**
5889     * @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
5890     */
5891    public StructureMap setCopyrightElement(MarkdownType value) { 
5892      this.copyright = value;
5893      return this;
5894    }
5895
5896    /**
5897     * @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.
5898     */
5899    public String getCopyright() { 
5900      return this.copyright == null ? null : this.copyright.getValue();
5901    }
5902
5903    /**
5904     * @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.
5905     */
5906    public StructureMap setCopyright(String value) { 
5907      if (value == null)
5908        this.copyright = null;
5909      else {
5910        if (this.copyright == null)
5911          this.copyright = new MarkdownType();
5912        this.copyright.setValue(value);
5913      }
5914      return this;
5915    }
5916
5917    /**
5918     * @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.)
5919     */
5920    public List<StructureMapStructureComponent> getStructure() { 
5921      if (this.structure == null)
5922        this.structure = new ArrayList<StructureMapStructureComponent>();
5923      return this.structure;
5924    }
5925
5926    /**
5927     * @return Returns a reference to <code>this</code> for easy method chaining
5928     */
5929    public StructureMap setStructure(List<StructureMapStructureComponent> theStructure) { 
5930      this.structure = theStructure;
5931      return this;
5932    }
5933
5934    public boolean hasStructure() { 
5935      if (this.structure == null)
5936        return false;
5937      for (StructureMapStructureComponent item : this.structure)
5938        if (!item.isEmpty())
5939          return true;
5940      return false;
5941    }
5942
5943    public StructureMapStructureComponent addStructure() { //3
5944      StructureMapStructureComponent t = new StructureMapStructureComponent();
5945      if (this.structure == null)
5946        this.structure = new ArrayList<StructureMapStructureComponent>();
5947      this.structure.add(t);
5948      return t;
5949    }
5950
5951    public StructureMap addStructure(StructureMapStructureComponent t) { //3
5952      if (t == null)
5953        return this;
5954      if (this.structure == null)
5955        this.structure = new ArrayList<StructureMapStructureComponent>();
5956      this.structure.add(t);
5957      return this;
5958    }
5959
5960    /**
5961     * @return The first repetition of repeating field {@link #structure}, creating it if it does not already exist {3}
5962     */
5963    public StructureMapStructureComponent getStructureFirstRep() { 
5964      if (getStructure().isEmpty()) {
5965        addStructure();
5966      }
5967      return getStructure().get(0);
5968    }
5969
5970    /**
5971     * @return {@link #import_} (Other maps used by this map (canonical URLs).)
5972     */
5973    public List<CanonicalType> getImport() { 
5974      if (this.import_ == null)
5975        this.import_ = new ArrayList<CanonicalType>();
5976      return this.import_;
5977    }
5978
5979    /**
5980     * @return Returns a reference to <code>this</code> for easy method chaining
5981     */
5982    public StructureMap setImport(List<CanonicalType> theImport) { 
5983      this.import_ = theImport;
5984      return this;
5985    }
5986
5987    public boolean hasImport() { 
5988      if (this.import_ == null)
5989        return false;
5990      for (CanonicalType item : this.import_)
5991        if (!item.isEmpty())
5992          return true;
5993      return false;
5994    }
5995
5996    /**
5997     * @return {@link #import_} (Other maps used by this map (canonical URLs).)
5998     */
5999    public CanonicalType addImportElement() {//2 
6000      CanonicalType t = new CanonicalType();
6001      if (this.import_ == null)
6002        this.import_ = new ArrayList<CanonicalType>();
6003      this.import_.add(t);
6004      return t;
6005    }
6006
6007    /**
6008     * @param value {@link #import_} (Other maps used by this map (canonical URLs).)
6009     */
6010    public StructureMap addImport(String value) { //1
6011      CanonicalType t = new CanonicalType();
6012      t.setValue(value);
6013      if (this.import_ == null)
6014        this.import_ = new ArrayList<CanonicalType>();
6015      this.import_.add(t);
6016      return this;
6017    }
6018
6019    /**
6020     * @param value {@link #import_} (Other maps used by this map (canonical URLs).)
6021     */
6022    public boolean hasImport(String value) { 
6023      if (this.import_ == null)
6024        return false;
6025      for (CanonicalType v : this.import_)
6026        if (v.getValue().equals(value)) // canonical
6027          return true;
6028      return false;
6029    }
6030
6031    /**
6032     * @return {@link #group} (Organizes the mapping into manageable chunks for human review/ease of maintenance.)
6033     */
6034    public List<StructureMapGroupComponent> getGroup() { 
6035      if (this.group == null)
6036        this.group = new ArrayList<StructureMapGroupComponent>();
6037      return this.group;
6038    }
6039
6040    /**
6041     * @return Returns a reference to <code>this</code> for easy method chaining
6042     */
6043    public StructureMap setGroup(List<StructureMapGroupComponent> theGroup) { 
6044      this.group = theGroup;
6045      return this;
6046    }
6047
6048    public boolean hasGroup() { 
6049      if (this.group == null)
6050        return false;
6051      for (StructureMapGroupComponent item : this.group)
6052        if (!item.isEmpty())
6053          return true;
6054      return false;
6055    }
6056
6057    public StructureMapGroupComponent addGroup() { //3
6058      StructureMapGroupComponent t = new StructureMapGroupComponent();
6059      if (this.group == null)
6060        this.group = new ArrayList<StructureMapGroupComponent>();
6061      this.group.add(t);
6062      return t;
6063    }
6064
6065    public StructureMap addGroup(StructureMapGroupComponent t) { //3
6066      if (t == null)
6067        return this;
6068      if (this.group == null)
6069        this.group = new ArrayList<StructureMapGroupComponent>();
6070      this.group.add(t);
6071      return this;
6072    }
6073
6074    /**
6075     * @return The first repetition of repeating field {@link #group}, creating it if it does not already exist {3}
6076     */
6077    public StructureMapGroupComponent getGroupFirstRep() { 
6078      if (getGroup().isEmpty()) {
6079        addGroup();
6080      }
6081      return getGroup().get(0);
6082    }
6083
6084      protected void listChildren(List<Property> children) {
6085        super.listChildren(children);
6086        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 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));
6087        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));
6088        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));
6089        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));
6090        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the structure map.", 0, 1, title));
6091        children.add(new Property("status", "code", "The status of this structure map. Enables tracking the life-cycle of the content.", 0, 1, status));
6092        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));
6093        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));
6094        children.add(new Property("publisher", "string", "The name of the organization or individual that published the structure map.", 0, 1, publisher));
6095        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));
6096        children.add(new Property("description", "markdown", "A free text natural language description of the structure map from a consumer's perspective.", 0, 1, description));
6097        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));
6098        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));
6099        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));
6100        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));
6101        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));
6102        children.add(new Property("import", "canonical(StructureMap)", "Other maps used by this map (canonical URLs).", 0, java.lang.Integer.MAX_VALUE, import_));
6103        children.add(new Property("group", "", "Organizes the mapping into manageable chunks for human review/ease of maintenance.", 0, java.lang.Integer.MAX_VALUE, group));
6104      }
6105
6106      @Override
6107      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
6108        switch (_hash) {
6109        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 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);
6110        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);
6111        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);
6112        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);
6113        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the structure map.", 0, 1, title);
6114        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);
6115        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);
6116        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);
6117        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the organization or individual that published the structure map.", 0, 1, publisher);
6118        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);
6119        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);
6120        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);
6121        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);
6122        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);
6123        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);
6124        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);
6125        case -1184795739: /*import*/  return new Property("import", "canonical(StructureMap)", "Other maps used by this map (canonical URLs).", 0, java.lang.Integer.MAX_VALUE, import_);
6126        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);
6127        default: return super.getNamedProperty(_hash, _name, _checkValid);
6128        }
6129
6130      }
6131
6132      @Override
6133      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
6134        switch (hash) {
6135        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
6136        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
6137        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
6138        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
6139        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
6140        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
6141        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
6142        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
6143        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
6144        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
6145        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
6146        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
6147        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
6148        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
6149        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
6150        case 144518515: /*structure*/ return this.structure == null ? new Base[0] : this.structure.toArray(new Base[this.structure.size()]); // StructureMapStructureComponent
6151        case -1184795739: /*import*/ return this.import_ == null ? new Base[0] : this.import_.toArray(new Base[this.import_.size()]); // CanonicalType
6152        case 98629247: /*group*/ return this.group == null ? new Base[0] : this.group.toArray(new Base[this.group.size()]); // StructureMapGroupComponent
6153        default: return super.getProperty(hash, name, checkValid);
6154        }
6155
6156      }
6157
6158      @Override
6159      public Base setProperty(int hash, String name, Base value) throws FHIRException {
6160        switch (hash) {
6161        case 116079: // url
6162          this.url = TypeConvertor.castToUri(value); // UriType
6163          return value;
6164        case -1618432855: // identifier
6165          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
6166          return value;
6167        case 351608024: // version
6168          this.version = TypeConvertor.castToString(value); // StringType
6169          return value;
6170        case 3373707: // name
6171          this.name = TypeConvertor.castToString(value); // StringType
6172          return value;
6173        case 110371416: // title
6174          this.title = TypeConvertor.castToString(value); // StringType
6175          return value;
6176        case -892481550: // status
6177          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
6178          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
6179          return value;
6180        case -404562712: // experimental
6181          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
6182          return value;
6183        case 3076014: // date
6184          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
6185          return value;
6186        case 1447404028: // publisher
6187          this.publisher = TypeConvertor.castToString(value); // StringType
6188          return value;
6189        case 951526432: // contact
6190          this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail
6191          return value;
6192        case -1724546052: // description
6193          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
6194          return value;
6195        case -669707736: // useContext
6196          this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext
6197          return value;
6198        case -507075711: // jurisdiction
6199          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
6200          return value;
6201        case -220463842: // purpose
6202          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
6203          return value;
6204        case 1522889671: // copyright
6205          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
6206          return value;
6207        case 144518515: // structure
6208          this.getStructure().add((StructureMapStructureComponent) value); // StructureMapStructureComponent
6209          return value;
6210        case -1184795739: // import
6211          this.getImport().add(TypeConvertor.castToCanonical(value)); // CanonicalType
6212          return value;
6213        case 98629247: // group
6214          this.getGroup().add((StructureMapGroupComponent) value); // StructureMapGroupComponent
6215          return value;
6216        default: return super.setProperty(hash, name, value);
6217        }
6218
6219      }
6220
6221      @Override
6222      public Base setProperty(String name, Base value) throws FHIRException {
6223        if (name.equals("url")) {
6224          this.url = TypeConvertor.castToUri(value); // UriType
6225        } else if (name.equals("identifier")) {
6226          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
6227        } else if (name.equals("version")) {
6228          this.version = TypeConvertor.castToString(value); // StringType
6229        } else if (name.equals("name")) {
6230          this.name = TypeConvertor.castToString(value); // StringType
6231        } else if (name.equals("title")) {
6232          this.title = TypeConvertor.castToString(value); // StringType
6233        } else if (name.equals("status")) {
6234          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
6235          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
6236        } else if (name.equals("experimental")) {
6237          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
6238        } else if (name.equals("date")) {
6239          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
6240        } else if (name.equals("publisher")) {
6241          this.publisher = TypeConvertor.castToString(value); // StringType
6242        } else if (name.equals("contact")) {
6243          this.getContact().add(TypeConvertor.castToContactDetail(value));
6244        } else if (name.equals("description")) {
6245          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
6246        } else if (name.equals("useContext")) {
6247          this.getUseContext().add(TypeConvertor.castToUsageContext(value));
6248        } else if (name.equals("jurisdiction")) {
6249          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value));
6250        } else if (name.equals("purpose")) {
6251          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
6252        } else if (name.equals("copyright")) {
6253          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
6254        } else if (name.equals("structure")) {
6255          this.getStructure().add((StructureMapStructureComponent) value);
6256        } else if (name.equals("import")) {
6257          this.getImport().add(TypeConvertor.castToCanonical(value));
6258        } else if (name.equals("group")) {
6259          this.getGroup().add((StructureMapGroupComponent) value);
6260        } else
6261          return super.setProperty(name, value);
6262        return value;
6263      }
6264
6265      @Override
6266      public Base makeProperty(int hash, String name) throws FHIRException {
6267        switch (hash) {
6268        case 116079:  return getUrlElement();
6269        case -1618432855:  return addIdentifier(); 
6270        case 351608024:  return getVersionElement();
6271        case 3373707:  return getNameElement();
6272        case 110371416:  return getTitleElement();
6273        case -892481550:  return getStatusElement();
6274        case -404562712:  return getExperimentalElement();
6275        case 3076014:  return getDateElement();
6276        case 1447404028:  return getPublisherElement();
6277        case 951526432:  return addContact(); 
6278        case -1724546052:  return getDescriptionElement();
6279        case -669707736:  return addUseContext(); 
6280        case -507075711:  return addJurisdiction(); 
6281        case -220463842:  return getPurposeElement();
6282        case 1522889671:  return getCopyrightElement();
6283        case 144518515:  return addStructure(); 
6284        case -1184795739:  return addImportElement();
6285        case 98629247:  return addGroup(); 
6286        default: return super.makeProperty(hash, name);
6287        }
6288
6289      }
6290
6291      @Override
6292      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6293        switch (hash) {
6294        case 116079: /*url*/ return new String[] {"uri"};
6295        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
6296        case 351608024: /*version*/ return new String[] {"string"};
6297        case 3373707: /*name*/ return new String[] {"string"};
6298        case 110371416: /*title*/ return new String[] {"string"};
6299        case -892481550: /*status*/ return new String[] {"code"};
6300        case -404562712: /*experimental*/ return new String[] {"boolean"};
6301        case 3076014: /*date*/ return new String[] {"dateTime"};
6302        case 1447404028: /*publisher*/ return new String[] {"string"};
6303        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
6304        case -1724546052: /*description*/ return new String[] {"markdown"};
6305        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
6306        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
6307        case -220463842: /*purpose*/ return new String[] {"markdown"};
6308        case 1522889671: /*copyright*/ return new String[] {"markdown"};
6309        case 144518515: /*structure*/ return new String[] {};
6310        case -1184795739: /*import*/ return new String[] {"canonical"};
6311        case 98629247: /*group*/ return new String[] {};
6312        default: return super.getTypesForProperty(hash, name);
6313        }
6314
6315      }
6316
6317      @Override
6318      public Base addChild(String name) throws FHIRException {
6319        if (name.equals("url")) {
6320          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.url");
6321        }
6322        else if (name.equals("identifier")) {
6323          return addIdentifier();
6324        }
6325        else if (name.equals("version")) {
6326          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.version");
6327        }
6328        else if (name.equals("name")) {
6329          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.name");
6330        }
6331        else if (name.equals("title")) {
6332          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.title");
6333        }
6334        else if (name.equals("status")) {
6335          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.status");
6336        }
6337        else if (name.equals("experimental")) {
6338          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.experimental");
6339        }
6340        else if (name.equals("date")) {
6341          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.date");
6342        }
6343        else if (name.equals("publisher")) {
6344          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.publisher");
6345        }
6346        else if (name.equals("contact")) {
6347          return addContact();
6348        }
6349        else if (name.equals("description")) {
6350          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.description");
6351        }
6352        else if (name.equals("useContext")) {
6353          return addUseContext();
6354        }
6355        else if (name.equals("jurisdiction")) {
6356          return addJurisdiction();
6357        }
6358        else if (name.equals("purpose")) {
6359          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.purpose");
6360        }
6361        else if (name.equals("copyright")) {
6362          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.copyright");
6363        }
6364        else if (name.equals("structure")) {
6365          return addStructure();
6366        }
6367        else if (name.equals("import")) {
6368          throw new FHIRException("Cannot call addChild on a primitive type StructureMap.import");
6369        }
6370        else if (name.equals("group")) {
6371          return addGroup();
6372        }
6373        else
6374          return super.addChild(name);
6375      }
6376
6377  public String fhirType() {
6378    return "StructureMap";
6379
6380  }
6381
6382      public StructureMap copy() {
6383        StructureMap dst = new StructureMap();
6384        copyValues(dst);
6385        return dst;
6386      }
6387
6388      public void copyValues(StructureMap dst) {
6389        super.copyValues(dst);
6390        dst.url = url == null ? null : url.copy();
6391        if (identifier != null) {
6392          dst.identifier = new ArrayList<Identifier>();
6393          for (Identifier i : identifier)
6394            dst.identifier.add(i.copy());
6395        };
6396        dst.version = version == null ? null : version.copy();
6397        dst.name = name == null ? null : name.copy();
6398        dst.title = title == null ? null : title.copy();
6399        dst.status = status == null ? null : status.copy();
6400        dst.experimental = experimental == null ? null : experimental.copy();
6401        dst.date = date == null ? null : date.copy();
6402        dst.publisher = publisher == null ? null : publisher.copy();
6403        if (contact != null) {
6404          dst.contact = new ArrayList<ContactDetail>();
6405          for (ContactDetail i : contact)
6406            dst.contact.add(i.copy());
6407        };
6408        dst.description = description == null ? null : description.copy();
6409        if (useContext != null) {
6410          dst.useContext = new ArrayList<UsageContext>();
6411          for (UsageContext i : useContext)
6412            dst.useContext.add(i.copy());
6413        };
6414        if (jurisdiction != null) {
6415          dst.jurisdiction = new ArrayList<CodeableConcept>();
6416          for (CodeableConcept i : jurisdiction)
6417            dst.jurisdiction.add(i.copy());
6418        };
6419        dst.purpose = purpose == null ? null : purpose.copy();
6420        dst.copyright = copyright == null ? null : copyright.copy();
6421        if (structure != null) {
6422          dst.structure = new ArrayList<StructureMapStructureComponent>();
6423          for (StructureMapStructureComponent i : structure)
6424            dst.structure.add(i.copy());
6425        };
6426        if (import_ != null) {
6427          dst.import_ = new ArrayList<CanonicalType>();
6428          for (CanonicalType i : import_)
6429            dst.import_.add(i.copy());
6430        };
6431        if (group != null) {
6432          dst.group = new ArrayList<StructureMapGroupComponent>();
6433          for (StructureMapGroupComponent i : group)
6434            dst.group.add(i.copy());
6435        };
6436      }
6437
6438      protected StructureMap typedCopy() {
6439        return copy();
6440      }
6441
6442      @Override
6443      public boolean equalsDeep(Base other_) {
6444        if (!super.equalsDeep(other_))
6445          return false;
6446        if (!(other_ instanceof StructureMap))
6447          return false;
6448        StructureMap o = (StructureMap) other_;
6449        return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true)
6450           && compareDeep(name, o.name, true) && compareDeep(title, o.title, true) && compareDeep(status, o.status, true)
6451           && compareDeep(experimental, o.experimental, true) && compareDeep(date, o.date, true) && compareDeep(publisher, o.publisher, true)
6452           && compareDeep(contact, o.contact, true) && compareDeep(description, o.description, true) && compareDeep(useContext, o.useContext, true)
6453           && compareDeep(jurisdiction, o.jurisdiction, true) && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true)
6454           && compareDeep(structure, o.structure, true) && compareDeep(import_, o.import_, true) && compareDeep(group, o.group, true)
6455          ;
6456      }
6457
6458      @Override
6459      public boolean equalsShallow(Base other_) {
6460        if (!super.equalsShallow(other_))
6461          return false;
6462        if (!(other_ instanceof StructureMap))
6463          return false;
6464        StructureMap o = (StructureMap) other_;
6465        return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true)
6466           && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true)
6467           && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true)
6468           && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(import_, o.import_, true)
6469          ;
6470      }
6471
6472      public boolean isEmpty() {
6473        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version
6474          , name, title, status, experimental, date, publisher, contact, description, useContext
6475          , jurisdiction, purpose, copyright, structure, import_, group);
6476      }
6477
6478  @Override
6479  public ResourceType getResourceType() {
6480    return ResourceType.StructureMap;
6481   }
6482
6483 /**
6484   * Search parameter: <b>context-quantity</b>
6485   * <p>
6486   * Description: <b>Multiple Resources: 
6487
6488* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
6489* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
6490* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
6491* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
6492* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
6493* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
6494* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
6495* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
6496* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
6497* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
6498* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
6499* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
6500* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
6501* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
6502</b><br>
6503   * Type: <b>quantity</b><br>
6504   * 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>
6505   * </p>
6506   */
6507  @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" )
6508  public static final String SP_CONTEXT_QUANTITY = "context-quantity";
6509 /**
6510   * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b>
6511   * <p>
6512   * Description: <b>Multiple Resources: 
6513
6514* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
6515* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
6516* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
6517* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
6518* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
6519* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
6520* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
6521* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
6522* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
6523* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
6524* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
6525* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
6526* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
6527* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
6528</b><br>
6529   * Type: <b>quantity</b><br>
6530   * 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>
6531   * </p>
6532   */
6533  public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY);
6534
6535 /**
6536   * Search parameter: <b>context-type-quantity</b>
6537   * <p>
6538   * Description: <b>Multiple Resources: 
6539
6540* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
6541* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
6542* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
6543* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
6544* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
6545* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
6546* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
6547* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
6548* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
6549* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
6550* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
6551* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
6552* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
6553* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
6554</b><br>
6555   * Type: <b>composite</b><br>
6556   * 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>
6557   * </p>
6558   */
6559  @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"} )
6560  public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity";
6561 /**
6562   * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b>
6563   * <p>
6564   * Description: <b>Multiple Resources: 
6565
6566* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
6567* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
6568* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
6569* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
6570* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
6571* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
6572* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
6573* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
6574* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
6575* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
6576* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
6577* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
6578* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
6579* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
6580</b><br>
6581   * Type: <b>composite</b><br>
6582   * 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>
6583   * </p>
6584   */
6585  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);
6586
6587 /**
6588   * Search parameter: <b>context-type-value</b>
6589   * <p>
6590   * Description: <b>Multiple Resources: 
6591
6592* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
6593* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
6594* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
6595* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
6596* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
6597* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
6598* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
6599* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
6600* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
6601* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
6602* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
6603* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
6604* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
6605* [ValueSet](valueset.html): A use context type and value assigned to the value set
6606</b><br>
6607   * Type: <b>composite</b><br>
6608   * 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>
6609   * </p>
6610   */
6611  @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"} )
6612  public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value";
6613 /**
6614   * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b>
6615   * <p>
6616   * Description: <b>Multiple Resources: 
6617
6618* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
6619* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
6620* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
6621* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
6622* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
6623* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
6624* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
6625* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
6626* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
6627* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
6628* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
6629* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
6630* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
6631* [ValueSet](valueset.html): A use context type and value assigned to the value set
6632</b><br>
6633   * Type: <b>composite</b><br>
6634   * 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>
6635   * </p>
6636   */
6637  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);
6638
6639 /**
6640   * Search parameter: <b>context-type</b>
6641   * <p>
6642   * Description: <b>Multiple Resources: 
6643
6644* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
6645* [CodeSystem](codesystem.html): A type of use context assigned to the code system
6646* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
6647* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
6648* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
6649* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
6650* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
6651* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
6652* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
6653* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
6654* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
6655* [StructureMap](structuremap.html): A type of use context assigned to the structure map
6656* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
6657* [ValueSet](valueset.html): A type of use context assigned to the value set
6658</b><br>
6659   * Type: <b>token</b><br>
6660   * 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>
6661   * </p>
6662   */
6663  @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" )
6664  public static final String SP_CONTEXT_TYPE = "context-type";
6665 /**
6666   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
6667   * <p>
6668   * Description: <b>Multiple Resources: 
6669
6670* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
6671* [CodeSystem](codesystem.html): A type of use context assigned to the code system
6672* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
6673* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
6674* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
6675* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
6676* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
6677* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
6678* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
6679* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
6680* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
6681* [StructureMap](structuremap.html): A type of use context assigned to the structure map
6682* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
6683* [ValueSet](valueset.html): A type of use context assigned to the value set
6684</b><br>
6685   * Type: <b>token</b><br>
6686   * 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>
6687   * </p>
6688   */
6689  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE);
6690
6691 /**
6692   * Search parameter: <b>context</b>
6693   * <p>
6694   * Description: <b>Multiple Resources: 
6695
6696* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
6697* [CodeSystem](codesystem.html): A use context assigned to the code system
6698* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
6699* [ConceptMap](conceptmap.html): A use context assigned to the concept map
6700* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
6701* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
6702* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
6703* [NamingSystem](namingsystem.html): A use context assigned to the naming system
6704* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
6705* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
6706* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
6707* [StructureMap](structuremap.html): A use context assigned to the structure map
6708* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
6709* [ValueSet](valueset.html): A use context assigned to the value set
6710</b><br>
6711   * Type: <b>token</b><br>
6712   * 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>
6713   * </p>
6714   */
6715  @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" )
6716  public static final String SP_CONTEXT = "context";
6717 /**
6718   * <b>Fluent Client</b> search parameter constant for <b>context</b>
6719   * <p>
6720   * Description: <b>Multiple Resources: 
6721
6722* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
6723* [CodeSystem](codesystem.html): A use context assigned to the code system
6724* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
6725* [ConceptMap](conceptmap.html): A use context assigned to the concept map
6726* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
6727* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
6728* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
6729* [NamingSystem](namingsystem.html): A use context assigned to the naming system
6730* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
6731* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
6732* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
6733* [StructureMap](structuremap.html): A use context assigned to the structure map
6734* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
6735* [ValueSet](valueset.html): A use context assigned to the value set
6736</b><br>
6737   * Type: <b>token</b><br>
6738   * 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>
6739   * </p>
6740   */
6741  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT);
6742
6743 /**
6744   * Search parameter: <b>date</b>
6745   * <p>
6746   * Description: <b>Multiple Resources: 
6747
6748* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
6749* [CodeSystem](codesystem.html): The code system publication date
6750* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
6751* [ConceptMap](conceptmap.html): The concept map publication date
6752* [GraphDefinition](graphdefinition.html): The graph definition publication date
6753* [ImplementationGuide](implementationguide.html): The implementation guide publication date
6754* [MessageDefinition](messagedefinition.html): The message definition publication date
6755* [NamingSystem](namingsystem.html): The naming system publication date
6756* [OperationDefinition](operationdefinition.html): The operation definition publication date
6757* [SearchParameter](searchparameter.html): The search parameter publication date
6758* [StructureDefinition](structuredefinition.html): The structure definition publication date
6759* [StructureMap](structuremap.html): The structure map publication date
6760* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
6761* [ValueSet](valueset.html): The value set publication date
6762</b><br>
6763   * Type: <b>date</b><br>
6764   * 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>
6765   * </p>
6766   */
6767  @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" )
6768  public static final String SP_DATE = "date";
6769 /**
6770   * <b>Fluent Client</b> search parameter constant for <b>date</b>
6771   * <p>
6772   * Description: <b>Multiple Resources: 
6773
6774* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
6775* [CodeSystem](codesystem.html): The code system publication date
6776* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
6777* [ConceptMap](conceptmap.html): The concept map publication date
6778* [GraphDefinition](graphdefinition.html): The graph definition publication date
6779* [ImplementationGuide](implementationguide.html): The implementation guide publication date
6780* [MessageDefinition](messagedefinition.html): The message definition publication date
6781* [NamingSystem](namingsystem.html): The naming system publication date
6782* [OperationDefinition](operationdefinition.html): The operation definition publication date
6783* [SearchParameter](searchparameter.html): The search parameter publication date
6784* [StructureDefinition](structuredefinition.html): The structure definition publication date
6785* [StructureMap](structuremap.html): The structure map publication date
6786* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
6787* [ValueSet](valueset.html): The value set publication date
6788</b><br>
6789   * Type: <b>date</b><br>
6790   * 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>
6791   * </p>
6792   */
6793  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
6794
6795 /**
6796   * Search parameter: <b>description</b>
6797   * <p>
6798   * Description: <b>Multiple Resources: 
6799
6800* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
6801* [CodeSystem](codesystem.html): The description of the code system
6802* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
6803* [ConceptMap](conceptmap.html): The description of the concept map
6804* [GraphDefinition](graphdefinition.html): The description of the graph definition
6805* [ImplementationGuide](implementationguide.html): The description of the implementation guide
6806* [MessageDefinition](messagedefinition.html): The description of the message definition
6807* [NamingSystem](namingsystem.html): The description of the naming system
6808* [OperationDefinition](operationdefinition.html): The description of the operation definition
6809* [SearchParameter](searchparameter.html): The description of the search parameter
6810* [StructureDefinition](structuredefinition.html): The description of the structure definition
6811* [StructureMap](structuremap.html): The description of the structure map
6812* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
6813* [ValueSet](valueset.html): The description of the value set
6814</b><br>
6815   * Type: <b>string</b><br>
6816   * 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>
6817   * </p>
6818   */
6819  @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" )
6820  public static final String SP_DESCRIPTION = "description";
6821 /**
6822   * <b>Fluent Client</b> search parameter constant for <b>description</b>
6823   * <p>
6824   * Description: <b>Multiple Resources: 
6825
6826* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
6827* [CodeSystem](codesystem.html): The description of the code system
6828* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
6829* [ConceptMap](conceptmap.html): The description of the concept map
6830* [GraphDefinition](graphdefinition.html): The description of the graph definition
6831* [ImplementationGuide](implementationguide.html): The description of the implementation guide
6832* [MessageDefinition](messagedefinition.html): The description of the message definition
6833* [NamingSystem](namingsystem.html): The description of the naming system
6834* [OperationDefinition](operationdefinition.html): The description of the operation definition
6835* [SearchParameter](searchparameter.html): The description of the search parameter
6836* [StructureDefinition](structuredefinition.html): The description of the structure definition
6837* [StructureMap](structuremap.html): The description of the structure map
6838* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
6839* [ValueSet](valueset.html): The description of the value set
6840</b><br>
6841   * Type: <b>string</b><br>
6842   * 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>
6843   * </p>
6844   */
6845  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
6846
6847 /**
6848   * Search parameter: <b>identifier</b>
6849   * <p>
6850   * Description: <b>Multiple Resources: 
6851
6852* [CodeSystem](codesystem.html): External identifier for the code system
6853* [ConceptMap](conceptmap.html): External identifier for the concept map
6854* [MessageDefinition](messagedefinition.html): External identifier for the message definition
6855* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
6856* [StructureMap](structuremap.html): External identifier for the structure map
6857* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
6858* [ValueSet](valueset.html): External identifier for the value set
6859</b><br>
6860   * Type: <b>token</b><br>
6861   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier</b><br>
6862   * </p>
6863   */
6864  @SearchParamDefinition(name="identifier", path="CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.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* [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" )
6865  public static final String SP_IDENTIFIER = "identifier";
6866 /**
6867   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
6868   * <p>
6869   * Description: <b>Multiple Resources: 
6870
6871* [CodeSystem](codesystem.html): External identifier for the code system
6872* [ConceptMap](conceptmap.html): External identifier for the concept map
6873* [MessageDefinition](messagedefinition.html): External identifier for the message definition
6874* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
6875* [StructureMap](structuremap.html): External identifier for the structure map
6876* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
6877* [ValueSet](valueset.html): External identifier for the value set
6878</b><br>
6879   * Type: <b>token</b><br>
6880   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier</b><br>
6881   * </p>
6882   */
6883  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
6884
6885 /**
6886   * Search parameter: <b>jurisdiction</b>
6887   * <p>
6888   * Description: <b>Multiple Resources: 
6889
6890* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
6891* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
6892* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
6893* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
6894* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
6895* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
6896* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
6897* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
6898* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
6899* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
6900* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
6901* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
6902* [ValueSet](valueset.html): Intended jurisdiction for the value set
6903</b><br>
6904   * Type: <b>token</b><br>
6905   * 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>
6906   * </p>
6907   */
6908  @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" )
6909  public static final String SP_JURISDICTION = "jurisdiction";
6910 /**
6911   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
6912   * <p>
6913   * Description: <b>Multiple Resources: 
6914
6915* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
6916* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
6917* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
6918* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
6919* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
6920* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
6921* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
6922* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
6923* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
6924* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
6925* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
6926* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
6927* [ValueSet](valueset.html): Intended jurisdiction for the value set
6928</b><br>
6929   * Type: <b>token</b><br>
6930   * 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>
6931   * </p>
6932   */
6933  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
6934
6935 /**
6936   * Search parameter: <b>name</b>
6937   * <p>
6938   * Description: <b>Multiple Resources: 
6939
6940* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
6941* [CodeSystem](codesystem.html): Computationally friendly name of the code system
6942* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
6943* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
6944* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
6945* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
6946* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
6947* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
6948* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
6949* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
6950* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
6951* [StructureMap](structuremap.html): Computationally friendly name of the structure map
6952* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
6953* [ValueSet](valueset.html): Computationally friendly name of the value set
6954</b><br>
6955   * Type: <b>string</b><br>
6956   * 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>
6957   * </p>
6958   */
6959  @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" )
6960  public static final String SP_NAME = "name";
6961 /**
6962   * <b>Fluent Client</b> search parameter constant for <b>name</b>
6963   * <p>
6964   * Description: <b>Multiple Resources: 
6965
6966* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
6967* [CodeSystem](codesystem.html): Computationally friendly name of the code system
6968* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
6969* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
6970* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
6971* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
6972* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
6973* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
6974* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
6975* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
6976* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
6977* [StructureMap](structuremap.html): Computationally friendly name of the structure map
6978* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
6979* [ValueSet](valueset.html): Computationally friendly name of the value set
6980</b><br>
6981   * Type: <b>string</b><br>
6982   * 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>
6983   * </p>
6984   */
6985  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
6986
6987 /**
6988   * Search parameter: <b>publisher</b>
6989   * <p>
6990   * Description: <b>Multiple Resources: 
6991
6992* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
6993* [CodeSystem](codesystem.html): Name of the publisher of the code system
6994* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
6995* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
6996* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
6997* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
6998* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
6999* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
7000* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
7001* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
7002* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
7003* [StructureMap](structuremap.html): Name of the publisher of the structure map
7004* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
7005* [ValueSet](valueset.html): Name of the publisher of the value set
7006</b><br>
7007   * Type: <b>string</b><br>
7008   * 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>
7009   * </p>
7010   */
7011  @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" )
7012  public static final String SP_PUBLISHER = "publisher";
7013 /**
7014   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
7015   * <p>
7016   * Description: <b>Multiple Resources: 
7017
7018* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
7019* [CodeSystem](codesystem.html): Name of the publisher of the code system
7020* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
7021* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
7022* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
7023* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
7024* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
7025* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
7026* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
7027* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
7028* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
7029* [StructureMap](structuremap.html): Name of the publisher of the structure map
7030* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
7031* [ValueSet](valueset.html): Name of the publisher of the value set
7032</b><br>
7033   * Type: <b>string</b><br>
7034   * 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>
7035   * </p>
7036   */
7037  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
7038
7039 /**
7040   * Search parameter: <b>status</b>
7041   * <p>
7042   * Description: <b>Multiple Resources: 
7043
7044* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
7045* [CodeSystem](codesystem.html): The current status of the code system
7046* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
7047* [ConceptMap](conceptmap.html): The current status of the concept map
7048* [GraphDefinition](graphdefinition.html): The current status of the graph definition
7049* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
7050* [MessageDefinition](messagedefinition.html): The current status of the message definition
7051* [NamingSystem](namingsystem.html): The current status of the naming system
7052* [OperationDefinition](operationdefinition.html): The current status of the operation definition
7053* [SearchParameter](searchparameter.html): The current status of the search parameter
7054* [StructureDefinition](structuredefinition.html): The current status of the structure definition
7055* [StructureMap](structuremap.html): The current status of the structure map
7056* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
7057* [ValueSet](valueset.html): The current status of the value set
7058</b><br>
7059   * Type: <b>token</b><br>
7060   * 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>
7061   * </p>
7062   */
7063  @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" )
7064  public static final String SP_STATUS = "status";
7065 /**
7066   * <b>Fluent Client</b> search parameter constant for <b>status</b>
7067   * <p>
7068   * Description: <b>Multiple Resources: 
7069
7070* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
7071* [CodeSystem](codesystem.html): The current status of the code system
7072* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
7073* [ConceptMap](conceptmap.html): The current status of the concept map
7074* [GraphDefinition](graphdefinition.html): The current status of the graph definition
7075* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
7076* [MessageDefinition](messagedefinition.html): The current status of the message definition
7077* [NamingSystem](namingsystem.html): The current status of the naming system
7078* [OperationDefinition](operationdefinition.html): The current status of the operation definition
7079* [SearchParameter](searchparameter.html): The current status of the search parameter
7080* [StructureDefinition](structuredefinition.html): The current status of the structure definition
7081* [StructureMap](structuremap.html): The current status of the structure map
7082* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
7083* [ValueSet](valueset.html): The current status of the value set
7084</b><br>
7085   * Type: <b>token</b><br>
7086   * 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>
7087   * </p>
7088   */
7089  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
7090
7091 /**
7092   * Search parameter: <b>title</b>
7093   * <p>
7094   * Description: <b>Multiple Resources: 
7095
7096* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
7097* [CodeSystem](codesystem.html): The human-friendly name of the code system
7098* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
7099* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
7100* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
7101* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
7102* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
7103* [StructureMap](structuremap.html): The human-friendly name of the structure map
7104* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
7105* [ValueSet](valueset.html): The human-friendly name of the value set
7106</b><br>
7107   * Type: <b>string</b><br>
7108   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
7109   * </p>
7110   */
7111  @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" )
7112  public static final String SP_TITLE = "title";
7113 /**
7114   * <b>Fluent Client</b> search parameter constant for <b>title</b>
7115   * <p>
7116   * Description: <b>Multiple Resources: 
7117
7118* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
7119* [CodeSystem](codesystem.html): The human-friendly name of the code system
7120* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
7121* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
7122* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
7123* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
7124* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
7125* [StructureMap](structuremap.html): The human-friendly name of the structure map
7126* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
7127* [ValueSet](valueset.html): The human-friendly name of the value set
7128</b><br>
7129   * Type: <b>string</b><br>
7130   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
7131   * </p>
7132   */
7133  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
7134
7135 /**
7136   * Search parameter: <b>url</b>
7137   * <p>
7138   * Description: <b>Multiple Resources: 
7139
7140* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
7141* [CodeSystem](codesystem.html): The uri that identifies the code system
7142* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
7143* [ConceptMap](conceptmap.html): The uri that identifies the concept map
7144* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
7145* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
7146* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
7147* [NamingSystem](namingsystem.html): The uri that identifies the naming system
7148* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
7149* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
7150* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
7151* [StructureMap](structuremap.html): The uri that identifies the structure map
7152* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
7153* [ValueSet](valueset.html): The uri that identifies the value set
7154</b><br>
7155   * Type: <b>uri</b><br>
7156   * 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>
7157   * </p>
7158   */
7159  @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" )
7160  public static final String SP_URL = "url";
7161 /**
7162   * <b>Fluent Client</b> search parameter constant for <b>url</b>
7163   * <p>
7164   * Description: <b>Multiple Resources: 
7165
7166* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
7167* [CodeSystem](codesystem.html): The uri that identifies the code system
7168* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
7169* [ConceptMap](conceptmap.html): The uri that identifies the concept map
7170* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
7171* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
7172* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
7173* [NamingSystem](namingsystem.html): The uri that identifies the naming system
7174* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
7175* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
7176* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
7177* [StructureMap](structuremap.html): The uri that identifies the structure map
7178* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
7179* [ValueSet](valueset.html): The uri that identifies the value set
7180</b><br>
7181   * Type: <b>uri</b><br>
7182   * 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>
7183   * </p>
7184   */
7185  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
7186
7187 /**
7188   * Search parameter: <b>version</b>
7189   * <p>
7190   * Description: <b>Multiple Resources: 
7191
7192* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
7193* [CodeSystem](codesystem.html): The business version of the code system
7194* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
7195* [ConceptMap](conceptmap.html): The business version of the concept map
7196* [GraphDefinition](graphdefinition.html): The business version of the graph definition
7197* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
7198* [MessageDefinition](messagedefinition.html): The business version of the message definition
7199* [NamingSystem](namingsystem.html): The business version of the naming system
7200* [OperationDefinition](operationdefinition.html): The business version of the operation definition
7201* [SearchParameter](searchparameter.html): The business version of the search parameter
7202* [StructureDefinition](structuredefinition.html): The business version of the structure definition
7203* [StructureMap](structuremap.html): The business version of the structure map
7204* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
7205* [ValueSet](valueset.html): The business version of the value set
7206</b><br>
7207   * Type: <b>token</b><br>
7208   * 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>
7209   * </p>
7210   */
7211  @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" )
7212  public static final String SP_VERSION = "version";
7213 /**
7214   * <b>Fluent Client</b> search parameter constant for <b>version</b>
7215   * <p>
7216   * Description: <b>Multiple Resources: 
7217
7218* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
7219* [CodeSystem](codesystem.html): The business version of the code system
7220* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
7221* [ConceptMap](conceptmap.html): The business version of the concept map
7222* [GraphDefinition](graphdefinition.html): The business version of the graph definition
7223* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
7224* [MessageDefinition](messagedefinition.html): The business version of the message definition
7225* [NamingSystem](namingsystem.html): The business version of the naming system
7226* [OperationDefinition](operationdefinition.html): The business version of the operation definition
7227* [SearchParameter](searchparameter.html): The business version of the search parameter
7228* [StructureDefinition](structuredefinition.html): The business version of the structure definition
7229* [StructureMap](structuremap.html): The business version of the structure map
7230* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
7231* [ValueSet](valueset.html): The business version of the value set
7232</b><br>
7233   * Type: <b>token</b><br>
7234   * 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>
7235   * </p>
7236   */
7237  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
7238
7239// Manual code (from Configuration.txt):
7240public String toString() {
7241    return StructureMapUtilities.render(this);
7242  }
7243// end addition
7244
7245}
7246