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