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