001package org.hl7.fhir.dstu3.model;
002
003/*
004  Copyright (c) 2011+, HL7, Inc.
005  All rights reserved.
006  
007  Redistribution and use in source and binary forms, with or without modification, 
008  are permitted provided that the following conditions are met:
009  
010   * Redistributions of source code must retain the above copyright notice, this 
011     list of conditions and the following disclaimer.
012   * Redistributions in binary form must reproduce the above copyright notice, 
013     this list of conditions and the following disclaimer in the documentation 
014     and/or other materials provided with the distribution.
015   * Neither the name of HL7 nor the names of its contributors may be used to 
016     endorse or promote products derived from this software without specific 
017     prior written permission.
018  
019  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
020  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
021  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
022  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
023  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
024  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
025  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
026  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
027  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
028  POSSIBILITY OF SUCH DAMAGE.
029  
030*/
031
032// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.1
033
034import java.util.*;
035
036import org.hl7.fhir.utilities.Utilities;
037import org.hl7.fhir.dstu3.model.Enumerations.*;
038import ca.uhn.fhir.model.api.annotation.ResourceDef;
039import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
040import ca.uhn.fhir.model.api.annotation.Child;
041import ca.uhn.fhir.model.api.annotation.ChildOrder;
042import ca.uhn.fhir.model.api.annotation.Description;
043import ca.uhn.fhir.model.api.annotation.Block;
044import org.hl7.fhir.instance.model.api.*;
045import org.hl7.fhir.exceptions.FHIRException;
046import org.hl7.fhir.exceptions.FHIRFormatError;
047/**
048 * A search parameter that defines a named search item that can be used to search/filter on a resource.
049 */
050@ResourceDef(name="SearchParameter", profile="http://hl7.org/fhir/StructureDefinition/SearchParameter")
051@ChildOrder(names={"url", "version", "name", "status", "experimental", "date", "publisher", "contact", "useContext", "jurisdiction", "purpose", "code", "base", "type", "derivedFrom", "description", "expression", "xpath", "xpathUsage", "target", "comparator", "modifier", "chain", "component"})
052public class SearchParameter extends MetadataResource {
053
054    public enum XPathUsageType {
055        /**
056         * The search parameter is derived directly from the selected nodes based on the type definitions.
057         */
058        NORMAL, 
059        /**
060         * The search parameter is derived by a phonetic transform from the selected nodes.
061         */
062        PHONETIC, 
063        /**
064         * The search parameter is based on a spatial transform of the selected nodes.
065         */
066        NEARBY, 
067        /**
068         * The search parameter is based on a spatial transform of the selected nodes, using physical distance from the middle.
069         */
070        DISTANCE, 
071        /**
072         * The interpretation of the xpath statement is unknown (and can't be automated).
073         */
074        OTHER, 
075        /**
076         * added to help the parsers with the generic types
077         */
078        NULL;
079        public static XPathUsageType fromCode(String codeString) throws FHIRException {
080            if (codeString == null || "".equals(codeString))
081                return null;
082        if ("normal".equals(codeString))
083          return NORMAL;
084        if ("phonetic".equals(codeString))
085          return PHONETIC;
086        if ("nearby".equals(codeString))
087          return NEARBY;
088        if ("distance".equals(codeString))
089          return DISTANCE;
090        if ("other".equals(codeString))
091          return OTHER;
092        if (Configuration.isAcceptInvalidEnums())
093          return null;
094        else
095          throw new FHIRException("Unknown XPathUsageType code '"+codeString+"'");
096        }
097        public String toCode() {
098          switch (this) {
099            case NORMAL: return "normal";
100            case PHONETIC: return "phonetic";
101            case NEARBY: return "nearby";
102            case DISTANCE: return "distance";
103            case OTHER: return "other";
104            default: return "?";
105          }
106        }
107        public String getSystem() {
108          switch (this) {
109            case NORMAL: return "http://hl7.org/fhir/search-xpath-usage";
110            case PHONETIC: return "http://hl7.org/fhir/search-xpath-usage";
111            case NEARBY: return "http://hl7.org/fhir/search-xpath-usage";
112            case DISTANCE: return "http://hl7.org/fhir/search-xpath-usage";
113            case OTHER: return "http://hl7.org/fhir/search-xpath-usage";
114            default: return "?";
115          }
116        }
117        public String getDefinition() {
118          switch (this) {
119            case NORMAL: return "The search parameter is derived directly from the selected nodes based on the type definitions.";
120            case PHONETIC: return "The search parameter is derived by a phonetic transform from the selected nodes.";
121            case NEARBY: return "The search parameter is based on a spatial transform of the selected nodes.";
122            case DISTANCE: return "The search parameter is based on a spatial transform of the selected nodes, using physical distance from the middle.";
123            case OTHER: return "The interpretation of the xpath statement is unknown (and can't be automated).";
124            default: return "?";
125          }
126        }
127        public String getDisplay() {
128          switch (this) {
129            case NORMAL: return "Normal";
130            case PHONETIC: return "Phonetic";
131            case NEARBY: return "Nearby";
132            case DISTANCE: return "Distance";
133            case OTHER: return "Other";
134            default: return "?";
135          }
136        }
137    }
138
139  public static class XPathUsageTypeEnumFactory implements EnumFactory<XPathUsageType> {
140    public XPathUsageType fromCode(String codeString) throws IllegalArgumentException {
141      if (codeString == null || "".equals(codeString))
142            if (codeString == null || "".equals(codeString))
143                return null;
144        if ("normal".equals(codeString))
145          return XPathUsageType.NORMAL;
146        if ("phonetic".equals(codeString))
147          return XPathUsageType.PHONETIC;
148        if ("nearby".equals(codeString))
149          return XPathUsageType.NEARBY;
150        if ("distance".equals(codeString))
151          return XPathUsageType.DISTANCE;
152        if ("other".equals(codeString))
153          return XPathUsageType.OTHER;
154        throw new IllegalArgumentException("Unknown XPathUsageType code '"+codeString+"'");
155        }
156        public Enumeration<XPathUsageType> fromType(Base code) throws FHIRException {
157          if (code == null)
158            return null;
159          if (code.isEmpty())
160            return new Enumeration<XPathUsageType>(this);
161          String codeString = ((PrimitiveType) code).asStringValue();
162          if (codeString == null || "".equals(codeString))
163            return null;
164        if ("normal".equals(codeString))
165          return new Enumeration<XPathUsageType>(this, XPathUsageType.NORMAL);
166        if ("phonetic".equals(codeString))
167          return new Enumeration<XPathUsageType>(this, XPathUsageType.PHONETIC);
168        if ("nearby".equals(codeString))
169          return new Enumeration<XPathUsageType>(this, XPathUsageType.NEARBY);
170        if ("distance".equals(codeString))
171          return new Enumeration<XPathUsageType>(this, XPathUsageType.DISTANCE);
172        if ("other".equals(codeString))
173          return new Enumeration<XPathUsageType>(this, XPathUsageType.OTHER);
174        throw new FHIRException("Unknown XPathUsageType code '"+codeString+"'");
175        }
176    public String toCode(XPathUsageType code) {
177      if (code == XPathUsageType.NORMAL)
178        return "normal";
179      if (code == XPathUsageType.PHONETIC)
180        return "phonetic";
181      if (code == XPathUsageType.NEARBY)
182        return "nearby";
183      if (code == XPathUsageType.DISTANCE)
184        return "distance";
185      if (code == XPathUsageType.OTHER)
186        return "other";
187      return "?";
188      }
189    public String toSystem(XPathUsageType code) {
190      return code.getSystem();
191      }
192    }
193
194    public enum SearchComparator {
195        /**
196         * the value for the parameter in the resource is equal to the provided value
197         */
198        EQ, 
199        /**
200         * the value for the parameter in the resource is not equal to the provided value
201         */
202        NE, 
203        /**
204         * the value for the parameter in the resource is greater than the provided value
205         */
206        GT, 
207        /**
208         * the value for the parameter in the resource is less than the provided value
209         */
210        LT, 
211        /**
212         * the value for the parameter in the resource is greater or equal to the provided value
213         */
214        GE, 
215        /**
216         * the value for the parameter in the resource is less or equal to the provided value
217         */
218        LE, 
219        /**
220         * the value for the parameter in the resource starts after the provided value
221         */
222        SA, 
223        /**
224         * the value for the parameter in the resource ends before the provided value
225         */
226        EB, 
227        /**
228         * the value for the parameter in the resource is approximately the same to the provided value.
229         */
230        AP, 
231        /**
232         * added to help the parsers with the generic types
233         */
234        NULL;
235        public static SearchComparator fromCode(String codeString) throws FHIRException {
236            if (codeString == null || "".equals(codeString))
237                return null;
238        if ("eq".equals(codeString))
239          return EQ;
240        if ("ne".equals(codeString))
241          return NE;
242        if ("gt".equals(codeString))
243          return GT;
244        if ("lt".equals(codeString))
245          return LT;
246        if ("ge".equals(codeString))
247          return GE;
248        if ("le".equals(codeString))
249          return LE;
250        if ("sa".equals(codeString))
251          return SA;
252        if ("eb".equals(codeString))
253          return EB;
254        if ("ap".equals(codeString))
255          return AP;
256        if (Configuration.isAcceptInvalidEnums())
257          return null;
258        else
259          throw new FHIRException("Unknown SearchComparator code '"+codeString+"'");
260        }
261        public String toCode() {
262          switch (this) {
263            case EQ: return "eq";
264            case NE: return "ne";
265            case GT: return "gt";
266            case LT: return "lt";
267            case GE: return "ge";
268            case LE: return "le";
269            case SA: return "sa";
270            case EB: return "eb";
271            case AP: return "ap";
272            default: return "?";
273          }
274        }
275        public String getSystem() {
276          switch (this) {
277            case EQ: return "http://hl7.org/fhir/search-comparator";
278            case NE: return "http://hl7.org/fhir/search-comparator";
279            case GT: return "http://hl7.org/fhir/search-comparator";
280            case LT: return "http://hl7.org/fhir/search-comparator";
281            case GE: return "http://hl7.org/fhir/search-comparator";
282            case LE: return "http://hl7.org/fhir/search-comparator";
283            case SA: return "http://hl7.org/fhir/search-comparator";
284            case EB: return "http://hl7.org/fhir/search-comparator";
285            case AP: return "http://hl7.org/fhir/search-comparator";
286            default: return "?";
287          }
288        }
289        public String getDefinition() {
290          switch (this) {
291            case EQ: return "the value for the parameter in the resource is equal to the provided value";
292            case NE: return "the value for the parameter in the resource is not equal to the provided value";
293            case GT: return "the value for the parameter in the resource is greater than the provided value";
294            case LT: return "the value for the parameter in the resource is less than the provided value";
295            case GE: return "the value for the parameter in the resource is greater or equal to the provided value";
296            case LE: return "the value for the parameter in the resource is less or equal to the provided value";
297            case SA: return "the value for the parameter in the resource starts after the provided value";
298            case EB: return "the value for the parameter in the resource ends before the provided value";
299            case AP: return "the value for the parameter in the resource is approximately the same to the provided value.";
300            default: return "?";
301          }
302        }
303        public String getDisplay() {
304          switch (this) {
305            case EQ: return "Equals";
306            case NE: return "Not Equals";
307            case GT: return "Greater Than";
308            case LT: return "Less Then";
309            case GE: return "Greater or Equals";
310            case LE: return "Less of Equal";
311            case SA: return "Starts After";
312            case EB: return "Ends Before";
313            case AP: return "Approximately";
314            default: return "?";
315          }
316        }
317    }
318
319  public static class SearchComparatorEnumFactory implements EnumFactory<SearchComparator> {
320    public SearchComparator fromCode(String codeString) throws IllegalArgumentException {
321      if (codeString == null || "".equals(codeString))
322            if (codeString == null || "".equals(codeString))
323                return null;
324        if ("eq".equals(codeString))
325          return SearchComparator.EQ;
326        if ("ne".equals(codeString))
327          return SearchComparator.NE;
328        if ("gt".equals(codeString))
329          return SearchComparator.GT;
330        if ("lt".equals(codeString))
331          return SearchComparator.LT;
332        if ("ge".equals(codeString))
333          return SearchComparator.GE;
334        if ("le".equals(codeString))
335          return SearchComparator.LE;
336        if ("sa".equals(codeString))
337          return SearchComparator.SA;
338        if ("eb".equals(codeString))
339          return SearchComparator.EB;
340        if ("ap".equals(codeString))
341          return SearchComparator.AP;
342        throw new IllegalArgumentException("Unknown SearchComparator code '"+codeString+"'");
343        }
344        public Enumeration<SearchComparator> fromType(Base code) throws FHIRException {
345          if (code == null)
346            return null;
347          if (code.isEmpty())
348            return new Enumeration<SearchComparator>(this);
349          String codeString = ((PrimitiveType) code).asStringValue();
350          if (codeString == null || "".equals(codeString))
351            return null;
352        if ("eq".equals(codeString))
353          return new Enumeration<SearchComparator>(this, SearchComparator.EQ);
354        if ("ne".equals(codeString))
355          return new Enumeration<SearchComparator>(this, SearchComparator.NE);
356        if ("gt".equals(codeString))
357          return new Enumeration<SearchComparator>(this, SearchComparator.GT);
358        if ("lt".equals(codeString))
359          return new Enumeration<SearchComparator>(this, SearchComparator.LT);
360        if ("ge".equals(codeString))
361          return new Enumeration<SearchComparator>(this, SearchComparator.GE);
362        if ("le".equals(codeString))
363          return new Enumeration<SearchComparator>(this, SearchComparator.LE);
364        if ("sa".equals(codeString))
365          return new Enumeration<SearchComparator>(this, SearchComparator.SA);
366        if ("eb".equals(codeString))
367          return new Enumeration<SearchComparator>(this, SearchComparator.EB);
368        if ("ap".equals(codeString))
369          return new Enumeration<SearchComparator>(this, SearchComparator.AP);
370        throw new FHIRException("Unknown SearchComparator code '"+codeString+"'");
371        }
372    public String toCode(SearchComparator code) {
373      if (code == SearchComparator.EQ)
374        return "eq";
375      if (code == SearchComparator.NE)
376        return "ne";
377      if (code == SearchComparator.GT)
378        return "gt";
379      if (code == SearchComparator.LT)
380        return "lt";
381      if (code == SearchComparator.GE)
382        return "ge";
383      if (code == SearchComparator.LE)
384        return "le";
385      if (code == SearchComparator.SA)
386        return "sa";
387      if (code == SearchComparator.EB)
388        return "eb";
389      if (code == SearchComparator.AP)
390        return "ap";
391      return "?";
392      }
393    public String toSystem(SearchComparator code) {
394      return code.getSystem();
395      }
396    }
397
398    public enum SearchModifierCode {
399        /**
400         * The search parameter returns resources that have a value or not.
401         */
402        MISSING, 
403        /**
404         * The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents).
405         */
406        EXACT, 
407        /**
408         * The search parameter returns resources that include the supplied parameter value anywhere within the field being searched.
409         */
410        CONTAINS, 
411        /**
412         * The search parameter returns resources that do not contain a match.
413         */
414        NOT, 
415        /**
416         * The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, or Identifier.type.text.
417         */
418        TEXT, 
419        /**
420         * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set.
421         */
422        IN, 
423        /**
424         * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set.
425         */
426        NOTIN, 
427        /**
428         * The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships).
429         */
430        BELOW, 
431        /**
432         * The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships).
433         */
434        ABOVE, 
435        /**
436         * The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.).
437         */
438        TYPE, 
439        /**
440         * added to help the parsers with the generic types
441         */
442        NULL;
443        public static SearchModifierCode fromCode(String codeString) throws FHIRException {
444            if (codeString == null || "".equals(codeString))
445                return null;
446        if ("missing".equals(codeString))
447          return MISSING;
448        if ("exact".equals(codeString))
449          return EXACT;
450        if ("contains".equals(codeString))
451          return CONTAINS;
452        if ("not".equals(codeString))
453          return NOT;
454        if ("text".equals(codeString))
455          return TEXT;
456        if ("in".equals(codeString))
457          return IN;
458        if ("not-in".equals(codeString))
459          return NOTIN;
460        if ("below".equals(codeString))
461          return BELOW;
462        if ("above".equals(codeString))
463          return ABOVE;
464        if ("type".equals(codeString))
465          return TYPE;
466        if (Configuration.isAcceptInvalidEnums())
467          return null;
468        else
469          throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'");
470        }
471        public String toCode() {
472          switch (this) {
473            case MISSING: return "missing";
474            case EXACT: return "exact";
475            case CONTAINS: return "contains";
476            case NOT: return "not";
477            case TEXT: return "text";
478            case IN: return "in";
479            case NOTIN: return "not-in";
480            case BELOW: return "below";
481            case ABOVE: return "above";
482            case TYPE: return "type";
483            default: return "?";
484          }
485        }
486        public String getSystem() {
487          switch (this) {
488            case MISSING: return "http://hl7.org/fhir/search-modifier-code";
489            case EXACT: return "http://hl7.org/fhir/search-modifier-code";
490            case CONTAINS: return "http://hl7.org/fhir/search-modifier-code";
491            case NOT: return "http://hl7.org/fhir/search-modifier-code";
492            case TEXT: return "http://hl7.org/fhir/search-modifier-code";
493            case IN: return "http://hl7.org/fhir/search-modifier-code";
494            case NOTIN: return "http://hl7.org/fhir/search-modifier-code";
495            case BELOW: return "http://hl7.org/fhir/search-modifier-code";
496            case ABOVE: return "http://hl7.org/fhir/search-modifier-code";
497            case TYPE: return "http://hl7.org/fhir/search-modifier-code";
498            default: return "?";
499          }
500        }
501        public String getDefinition() {
502          switch (this) {
503            case MISSING: return "The search parameter returns resources that have a value or not.";
504            case EXACT: return "The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents).";
505            case CONTAINS: return "The search parameter returns resources that include the supplied parameter value anywhere within the field being searched.";
506            case NOT: return "The search parameter returns resources that do not contain a match.";
507            case TEXT: return "The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, or Identifier.type.text.";
508            case IN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set.";
509            case NOTIN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set.";
510            case BELOW: return "The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships).";
511            case ABOVE: return "The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships).";
512            case TYPE: return "The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.).";
513            default: return "?";
514          }
515        }
516        public String getDisplay() {
517          switch (this) {
518            case MISSING: return "Missing";
519            case EXACT: return "Exact";
520            case CONTAINS: return "Contains";
521            case NOT: return "Not";
522            case TEXT: return "Text";
523            case IN: return "In";
524            case NOTIN: return "Not In";
525            case BELOW: return "Below";
526            case ABOVE: return "Above";
527            case TYPE: return "Type";
528            default: return "?";
529          }
530        }
531    }
532
533  public static class SearchModifierCodeEnumFactory implements EnumFactory<SearchModifierCode> {
534    public SearchModifierCode fromCode(String codeString) throws IllegalArgumentException {
535      if (codeString == null || "".equals(codeString))
536            if (codeString == null || "".equals(codeString))
537                return null;
538        if ("missing".equals(codeString))
539          return SearchModifierCode.MISSING;
540        if ("exact".equals(codeString))
541          return SearchModifierCode.EXACT;
542        if ("contains".equals(codeString))
543          return SearchModifierCode.CONTAINS;
544        if ("not".equals(codeString))
545          return SearchModifierCode.NOT;
546        if ("text".equals(codeString))
547          return SearchModifierCode.TEXT;
548        if ("in".equals(codeString))
549          return SearchModifierCode.IN;
550        if ("not-in".equals(codeString))
551          return SearchModifierCode.NOTIN;
552        if ("below".equals(codeString))
553          return SearchModifierCode.BELOW;
554        if ("above".equals(codeString))
555          return SearchModifierCode.ABOVE;
556        if ("type".equals(codeString))
557          return SearchModifierCode.TYPE;
558        throw new IllegalArgumentException("Unknown SearchModifierCode code '"+codeString+"'");
559        }
560        public Enumeration<SearchModifierCode> fromType(Base code) throws FHIRException {
561          if (code == null)
562            return null;
563          if (code.isEmpty())
564            return new Enumeration<SearchModifierCode>(this);
565          String codeString = ((PrimitiveType) code).asStringValue();
566          if (codeString == null || "".equals(codeString))
567            return null;
568        if ("missing".equals(codeString))
569          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.MISSING);
570        if ("exact".equals(codeString))
571          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.EXACT);
572        if ("contains".equals(codeString))
573          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CONTAINS);
574        if ("not".equals(codeString))
575          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOT);
576        if ("text".equals(codeString))
577          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXT);
578        if ("in".equals(codeString))
579          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IN);
580        if ("not-in".equals(codeString))
581          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOTIN);
582        if ("below".equals(codeString))
583          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.BELOW);
584        if ("above".equals(codeString))
585          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ABOVE);
586        if ("type".equals(codeString))
587          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TYPE);
588        throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'");
589        }
590    public String toCode(SearchModifierCode code) {
591      if (code == SearchModifierCode.MISSING)
592        return "missing";
593      if (code == SearchModifierCode.EXACT)
594        return "exact";
595      if (code == SearchModifierCode.CONTAINS)
596        return "contains";
597      if (code == SearchModifierCode.NOT)
598        return "not";
599      if (code == SearchModifierCode.TEXT)
600        return "text";
601      if (code == SearchModifierCode.IN)
602        return "in";
603      if (code == SearchModifierCode.NOTIN)
604        return "not-in";
605      if (code == SearchModifierCode.BELOW)
606        return "below";
607      if (code == SearchModifierCode.ABOVE)
608        return "above";
609      if (code == SearchModifierCode.TYPE)
610        return "type";
611      return "?";
612      }
613    public String toSystem(SearchModifierCode code) {
614      return code.getSystem();
615      }
616    }
617
618    @Block()
619    public static class SearchParameterComponentComponent extends BackboneElement implements IBaseBackboneElement {
620        /**
621         * The definition of the search parameter that describes this part.
622         */
623        @Child(name = "definition", type = {SearchParameter.class}, order=1, min=1, max=1, modifier=false, summary=false)
624        @Description(shortDefinition="Defines how the part works", formalDefinition="The definition of the search parameter that describes this part." )
625        protected Reference definition;
626
627        /**
628         * The actual object that is the target of the reference (The definition of the search parameter that describes this part.)
629         */
630        protected SearchParameter definitionTarget;
631
632        /**
633         * A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.
634         */
635        @Child(name = "expression", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=false)
636        @Description(shortDefinition="Subexpression relative to main expression", formalDefinition="A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression." )
637        protected StringType expression;
638
639        private static final long serialVersionUID = -1105563614L;
640
641    /**
642     * Constructor
643     */
644      public SearchParameterComponentComponent() {
645        super();
646      }
647
648    /**
649     * Constructor
650     */
651      public SearchParameterComponentComponent(Reference definition, StringType expression) {
652        super();
653        this.definition = definition;
654        this.expression = expression;
655      }
656
657        /**
658         * @return {@link #definition} (The definition of the search parameter that describes this part.)
659         */
660        public Reference getDefinition() { 
661          if (this.definition == null)
662            if (Configuration.errorOnAutoCreate())
663              throw new Error("Attempt to auto-create SearchParameterComponentComponent.definition");
664            else if (Configuration.doAutoCreate())
665              this.definition = new Reference(); // cc
666          return this.definition;
667        }
668
669        public boolean hasDefinition() { 
670          return this.definition != null && !this.definition.isEmpty();
671        }
672
673        /**
674         * @param value {@link #definition} (The definition of the search parameter that describes this part.)
675         */
676        public SearchParameterComponentComponent setDefinition(Reference value)  { 
677          this.definition = value;
678          return this;
679        }
680
681        /**
682         * @return {@link #definition} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The definition of the search parameter that describes this part.)
683         */
684        public SearchParameter getDefinitionTarget() { 
685          if (this.definitionTarget == null)
686            if (Configuration.errorOnAutoCreate())
687              throw new Error("Attempt to auto-create SearchParameterComponentComponent.definition");
688            else if (Configuration.doAutoCreate())
689              this.definitionTarget = new SearchParameter(); // aa
690          return this.definitionTarget;
691        }
692
693        /**
694         * @param value {@link #definition} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The definition of the search parameter that describes this part.)
695         */
696        public SearchParameterComponentComponent setDefinitionTarget(SearchParameter value) { 
697          this.definitionTarget = value;
698          return this;
699        }
700
701        /**
702         * @return {@link #expression} (A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
703         */
704        public StringType getExpressionElement() { 
705          if (this.expression == null)
706            if (Configuration.errorOnAutoCreate())
707              throw new Error("Attempt to auto-create SearchParameterComponentComponent.expression");
708            else if (Configuration.doAutoCreate())
709              this.expression = new StringType(); // bb
710          return this.expression;
711        }
712
713        public boolean hasExpressionElement() { 
714          return this.expression != null && !this.expression.isEmpty();
715        }
716
717        public boolean hasExpression() { 
718          return this.expression != null && !this.expression.isEmpty();
719        }
720
721        /**
722         * @param value {@link #expression} (A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
723         */
724        public SearchParameterComponentComponent setExpressionElement(StringType value) { 
725          this.expression = value;
726          return this;
727        }
728
729        /**
730         * @return A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.
731         */
732        public String getExpression() { 
733          return this.expression == null ? null : this.expression.getValue();
734        }
735
736        /**
737         * @param value A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.
738         */
739        public SearchParameterComponentComponent setExpression(String value) { 
740            if (this.expression == null)
741              this.expression = new StringType();
742            this.expression.setValue(value);
743          return this;
744        }
745
746        protected void listChildren(List<Property> children) {
747          super.listChildren(children);
748          children.add(new Property("definition", "Reference(SearchParameter)", "The definition of the search parameter that describes this part.", 0, 1, definition));
749          children.add(new Property("expression", "string", "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.", 0, 1, expression));
750        }
751
752        @Override
753        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
754          switch (_hash) {
755          case -1014418093: /*definition*/  return new Property("definition", "Reference(SearchParameter)", "The definition of the search parameter that describes this part.", 0, 1, definition);
756          case -1795452264: /*expression*/  return new Property("expression", "string", "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.", 0, 1, expression);
757          default: return super.getNamedProperty(_hash, _name, _checkValid);
758          }
759
760        }
761
762      @Override
763      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
764        switch (hash) {
765        case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // Reference
766        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
767        default: return super.getProperty(hash, name, checkValid);
768        }
769
770      }
771
772      @Override
773      public Base setProperty(int hash, String name, Base value) throws FHIRException {
774        switch (hash) {
775        case -1014418093: // definition
776          this.definition = castToReference(value); // Reference
777          return value;
778        case -1795452264: // expression
779          this.expression = castToString(value); // StringType
780          return value;
781        default: return super.setProperty(hash, name, value);
782        }
783
784      }
785
786      @Override
787      public Base setProperty(String name, Base value) throws FHIRException {
788        if (name.equals("definition")) {
789          this.definition = castToReference(value); // Reference
790        } else if (name.equals("expression")) {
791          this.expression = castToString(value); // StringType
792        } else
793          return super.setProperty(name, value);
794        return value;
795      }
796
797      @Override
798      public Base makeProperty(int hash, String name) throws FHIRException {
799        switch (hash) {
800        case -1014418093:  return getDefinition(); 
801        case -1795452264:  return getExpressionElement();
802        default: return super.makeProperty(hash, name);
803        }
804
805      }
806
807      @Override
808      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
809        switch (hash) {
810        case -1014418093: /*definition*/ return new String[] {"Reference"};
811        case -1795452264: /*expression*/ return new String[] {"string"};
812        default: return super.getTypesForProperty(hash, name);
813        }
814
815      }
816
817      @Override
818      public Base addChild(String name) throws FHIRException {
819        if (name.equals("definition")) {
820          this.definition = new Reference();
821          return this.definition;
822        }
823        else if (name.equals("expression")) {
824          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.expression");
825        }
826        else
827          return super.addChild(name);
828      }
829
830      public SearchParameterComponentComponent copy() {
831        SearchParameterComponentComponent dst = new SearchParameterComponentComponent();
832        copyValues(dst);
833        dst.definition = definition == null ? null : definition.copy();
834        dst.expression = expression == null ? null : expression.copy();
835        return dst;
836      }
837
838      @Override
839      public boolean equalsDeep(Base other_) {
840        if (!super.equalsDeep(other_))
841          return false;
842        if (!(other_ instanceof SearchParameterComponentComponent))
843          return false;
844        SearchParameterComponentComponent o = (SearchParameterComponentComponent) other_;
845        return compareDeep(definition, o.definition, true) && compareDeep(expression, o.expression, true)
846          ;
847      }
848
849      @Override
850      public boolean equalsShallow(Base other_) {
851        if (!super.equalsShallow(other_))
852          return false;
853        if (!(other_ instanceof SearchParameterComponentComponent))
854          return false;
855        SearchParameterComponentComponent o = (SearchParameterComponentComponent) other_;
856        return compareValues(expression, o.expression, true);
857      }
858
859      public boolean isEmpty() {
860        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(definition, expression);
861      }
862
863  public String fhirType() {
864    return "SearchParameter.component";
865
866  }
867
868  }
869
870    /**
871     * Explaination of why this search parameter is needed and why it has been designed as it has.
872     */
873    @Child(name = "purpose", type = {MarkdownType.class}, order=0, min=0, max=1, modifier=false, summary=false)
874    @Description(shortDefinition="Why this search parameter is defined", formalDefinition="Explaination of why this search parameter is needed and why it has been designed as it has." )
875    protected MarkdownType purpose;
876
877    /**
878     * The code used in the URL or the parameter name in a parameters resource for this search parameter.
879     */
880    @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
881    @Description(shortDefinition="Code used in URL", formalDefinition="The code used in the URL or the parameter name in a parameters resource for this search parameter." )
882    protected CodeType code;
883
884    /**
885     * The base resource type(s) that this search parameter can be used against.
886     */
887    @Child(name = "base", type = {CodeType.class}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
888    @Description(shortDefinition="The resource type(s) this search parameter applies to", formalDefinition="The base resource type(s) that this search parameter can be used against." )
889    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types")
890    protected List<CodeType> base;
891
892    /**
893     * The type of value a search parameter refers to, and how the content is interpreted.
894     */
895    @Child(name = "type", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true)
896    @Description(shortDefinition="number | date | string | token | reference | composite | quantity | uri", formalDefinition="The type of value a search parameter refers to, and how the content is interpreted." )
897    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-param-type")
898    protected Enumeration<SearchParamType> type;
899
900    /**
901     * Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.
902     */
903    @Child(name = "derivedFrom", type = {UriType.class}, order=4, min=0, max=1, modifier=false, summary=false)
904    @Description(shortDefinition="Original Definition for the search parameter", formalDefinition="Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter." )
905    protected UriType derivedFrom;
906
907    /**
908     * A FHIRPath expression that returns a set of elements for the search parameter.
909     */
910    @Child(name = "expression", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=false)
911    @Description(shortDefinition="FHIRPath expression that extracts the values", formalDefinition="A FHIRPath expression that returns a set of elements for the search parameter." )
912    protected StringType expression;
913
914    /**
915     * An XPath expression that returns a set of elements for the search parameter.
916     */
917    @Child(name = "xpath", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=false)
918    @Description(shortDefinition="XPath that extracts the values", formalDefinition="An XPath expression that returns a set of elements for the search parameter." )
919    protected StringType xpath;
920
921    /**
922     * How the search parameter relates to the set of elements returned by evaluating the xpath query.
923     */
924    @Child(name = "xpathUsage", type = {CodeType.class}, order=7, min=0, max=1, modifier=false, summary=false)
925    @Description(shortDefinition="normal | phonetic | nearby | distance | other", formalDefinition="How the search parameter relates to the set of elements returned by evaluating the xpath query." )
926    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-xpath-usage")
927    protected Enumeration<XPathUsageType> xpathUsage;
928
929    /**
930     * Types of resource (if a resource is referenced).
931     */
932    @Child(name = "target", type = {CodeType.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
933    @Description(shortDefinition="Types of resource (if a resource reference)", formalDefinition="Types of resource (if a resource is referenced)." )
934    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types")
935    protected List<CodeType> target;
936
937    /**
938     * Comparators supported for the search parameter.
939     */
940    @Child(name = "comparator", type = {CodeType.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
941    @Description(shortDefinition="eq | ne | gt | lt | ge | le | sa | eb | ap", formalDefinition="Comparators supported for the search parameter." )
942    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-comparator")
943    protected List<Enumeration<SearchComparator>> comparator;
944
945    /**
946     * A modifier supported for the search parameter.
947     */
948    @Child(name = "modifier", type = {CodeType.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
949    @Description(shortDefinition="missing | exact | contains | not | text | in | not-in | below | above | type", formalDefinition="A modifier supported for the search parameter." )
950    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-modifier-code")
951    protected List<Enumeration<SearchModifierCode>> modifier;
952
953    /**
954     * Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.
955     */
956    @Child(name = "chain", type = {StringType.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
957    @Description(shortDefinition="Chained names supported", formalDefinition="Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type." )
958    protected List<StringType> chain;
959
960    /**
961     * Used to define the parts of a composite search parameter.
962     */
963    @Child(name = "component", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
964    @Description(shortDefinition="For Composite resources to define the parts", formalDefinition="Used to define the parts of a composite search parameter." )
965    protected List<SearchParameterComponentComponent> component;
966
967    private static final long serialVersionUID = -769368159L;
968
969  /**
970   * Constructor
971   */
972    public SearchParameter() {
973      super();
974    }
975
976  /**
977   * Constructor
978   */
979    public SearchParameter(UriType url, StringType name, Enumeration<PublicationStatus> status, CodeType code, Enumeration<SearchParamType> type, MarkdownType description) {
980      super();
981      this.url = url;
982      this.name = name;
983      this.status = status;
984      this.code = code;
985      this.type = type;
986      this.description = description;
987    }
988
989    /**
990     * @return {@link #url} (An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
991     */
992    public UriType getUrlElement() { 
993      if (this.url == null)
994        if (Configuration.errorOnAutoCreate())
995          throw new Error("Attempt to auto-create SearchParameter.url");
996        else if (Configuration.doAutoCreate())
997          this.url = new UriType(); // bb
998      return this.url;
999    }
1000
1001    public boolean hasUrlElement() { 
1002      return this.url != null && !this.url.isEmpty();
1003    }
1004
1005    public boolean hasUrl() { 
1006      return this.url != null && !this.url.isEmpty();
1007    }
1008
1009    /**
1010     * @param value {@link #url} (An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1011     */
1012    public SearchParameter setUrlElement(UriType value) { 
1013      this.url = value;
1014      return this;
1015    }
1016
1017    /**
1018     * @return An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).
1019     */
1020    public String getUrl() { 
1021      return this.url == null ? null : this.url.getValue();
1022    }
1023
1024    /**
1025     * @param value An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).
1026     */
1027    public SearchParameter setUrl(String value) { 
1028        if (this.url == null)
1029          this.url = new UriType();
1030        this.url.setValue(value);
1031      return this;
1032    }
1033
1034    /**
1035     * @return {@link #version} (The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter 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
1036     */
1037    public StringType getVersionElement() { 
1038      if (this.version == null)
1039        if (Configuration.errorOnAutoCreate())
1040          throw new Error("Attempt to auto-create SearchParameter.version");
1041        else if (Configuration.doAutoCreate())
1042          this.version = new StringType(); // bb
1043      return this.version;
1044    }
1045
1046    public boolean hasVersionElement() { 
1047      return this.version != null && !this.version.isEmpty();
1048    }
1049
1050    public boolean hasVersion() { 
1051      return this.version != null && !this.version.isEmpty();
1052    }
1053
1054    /**
1055     * @param value {@link #version} (The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter 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
1056     */
1057    public SearchParameter setVersionElement(StringType value) { 
1058      this.version = value;
1059      return this;
1060    }
1061
1062    /**
1063     * @return The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter 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.
1064     */
1065    public String getVersion() { 
1066      return this.version == null ? null : this.version.getValue();
1067    }
1068
1069    /**
1070     * @param value The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter 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.
1071     */
1072    public SearchParameter setVersion(String value) { 
1073      if (Utilities.noString(value))
1074        this.version = null;
1075      else {
1076        if (this.version == null)
1077          this.version = new StringType();
1078        this.version.setValue(value);
1079      }
1080      return this;
1081    }
1082
1083    /**
1084     * @return {@link #name} (A natural language name identifying the search parameter. 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
1085     */
1086    public StringType getNameElement() { 
1087      if (this.name == null)
1088        if (Configuration.errorOnAutoCreate())
1089          throw new Error("Attempt to auto-create SearchParameter.name");
1090        else if (Configuration.doAutoCreate())
1091          this.name = new StringType(); // bb
1092      return this.name;
1093    }
1094
1095    public boolean hasNameElement() { 
1096      return this.name != null && !this.name.isEmpty();
1097    }
1098
1099    public boolean hasName() { 
1100      return this.name != null && !this.name.isEmpty();
1101    }
1102
1103    /**
1104     * @param value {@link #name} (A natural language name identifying the search parameter. 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
1105     */
1106    public SearchParameter setNameElement(StringType value) { 
1107      this.name = value;
1108      return this;
1109    }
1110
1111    /**
1112     * @return A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1113     */
1114    public String getName() { 
1115      return this.name == null ? null : this.name.getValue();
1116    }
1117
1118    /**
1119     * @param value A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1120     */
1121    public SearchParameter setName(String value) { 
1122        if (this.name == null)
1123          this.name = new StringType();
1124        this.name.setValue(value);
1125      return this;
1126    }
1127
1128    /**
1129     * @return {@link #status} (The status of this search parameter. 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
1130     */
1131    public Enumeration<PublicationStatus> getStatusElement() { 
1132      if (this.status == null)
1133        if (Configuration.errorOnAutoCreate())
1134          throw new Error("Attempt to auto-create SearchParameter.status");
1135        else if (Configuration.doAutoCreate())
1136          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
1137      return this.status;
1138    }
1139
1140    public boolean hasStatusElement() { 
1141      return this.status != null && !this.status.isEmpty();
1142    }
1143
1144    public boolean hasStatus() { 
1145      return this.status != null && !this.status.isEmpty();
1146    }
1147
1148    /**
1149     * @param value {@link #status} (The status of this search parameter. 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
1150     */
1151    public SearchParameter setStatusElement(Enumeration<PublicationStatus> value) { 
1152      this.status = value;
1153      return this;
1154    }
1155
1156    /**
1157     * @return The status of this search parameter. Enables tracking the life-cycle of the content.
1158     */
1159    public PublicationStatus getStatus() { 
1160      return this.status == null ? null : this.status.getValue();
1161    }
1162
1163    /**
1164     * @param value The status of this search parameter. Enables tracking the life-cycle of the content.
1165     */
1166    public SearchParameter setStatus(PublicationStatus value) { 
1167        if (this.status == null)
1168          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
1169        this.status.setValue(value);
1170      return this;
1171    }
1172
1173    /**
1174     * @return {@link #experimental} (A boolean value to indicate that this search parameter 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
1175     */
1176    public BooleanType getExperimentalElement() { 
1177      if (this.experimental == null)
1178        if (Configuration.errorOnAutoCreate())
1179          throw new Error("Attempt to auto-create SearchParameter.experimental");
1180        else if (Configuration.doAutoCreate())
1181          this.experimental = new BooleanType(); // bb
1182      return this.experimental;
1183    }
1184
1185    public boolean hasExperimentalElement() { 
1186      return this.experimental != null && !this.experimental.isEmpty();
1187    }
1188
1189    public boolean hasExperimental() { 
1190      return this.experimental != null && !this.experimental.isEmpty();
1191    }
1192
1193    /**
1194     * @param value {@link #experimental} (A boolean value to indicate that this search parameter 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
1195     */
1196    public SearchParameter setExperimentalElement(BooleanType value) { 
1197      this.experimental = value;
1198      return this;
1199    }
1200
1201    /**
1202     * @return A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
1203     */
1204    public boolean getExperimental() { 
1205      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
1206    }
1207
1208    /**
1209     * @param value A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
1210     */
1211    public SearchParameter setExperimental(boolean value) { 
1212        if (this.experimental == null)
1213          this.experimental = new BooleanType();
1214        this.experimental.setValue(value);
1215      return this;
1216    }
1217
1218    /**
1219     * @return {@link #date} (The date  (and optionally time) when the search parameter was published. The date must change if and 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 search parameter changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
1220     */
1221    public DateTimeType getDateElement() { 
1222      if (this.date == null)
1223        if (Configuration.errorOnAutoCreate())
1224          throw new Error("Attempt to auto-create SearchParameter.date");
1225        else if (Configuration.doAutoCreate())
1226          this.date = new DateTimeType(); // bb
1227      return this.date;
1228    }
1229
1230    public boolean hasDateElement() { 
1231      return this.date != null && !this.date.isEmpty();
1232    }
1233
1234    public boolean hasDate() { 
1235      return this.date != null && !this.date.isEmpty();
1236    }
1237
1238    /**
1239     * @param value {@link #date} (The date  (and optionally time) when the search parameter was published. The date must change if and 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 search parameter changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
1240     */
1241    public SearchParameter setDateElement(DateTimeType value) { 
1242      this.date = value;
1243      return this;
1244    }
1245
1246    /**
1247     * @return The date  (and optionally time) when the search parameter was published. The date must change if and 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 search parameter changes.
1248     */
1249    public Date getDate() { 
1250      return this.date == null ? null : this.date.getValue();
1251    }
1252
1253    /**
1254     * @param value The date  (and optionally time) when the search parameter was published. The date must change if and 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 search parameter changes.
1255     */
1256    public SearchParameter setDate(Date value) { 
1257      if (value == null)
1258        this.date = null;
1259      else {
1260        if (this.date == null)
1261          this.date = new DateTimeType();
1262        this.date.setValue(value);
1263      }
1264      return this;
1265    }
1266
1267    /**
1268     * @return {@link #publisher} (The name of the individual or organization that published the search parameter.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
1269     */
1270    public StringType getPublisherElement() { 
1271      if (this.publisher == null)
1272        if (Configuration.errorOnAutoCreate())
1273          throw new Error("Attempt to auto-create SearchParameter.publisher");
1274        else if (Configuration.doAutoCreate())
1275          this.publisher = new StringType(); // bb
1276      return this.publisher;
1277    }
1278
1279    public boolean hasPublisherElement() { 
1280      return this.publisher != null && !this.publisher.isEmpty();
1281    }
1282
1283    public boolean hasPublisher() { 
1284      return this.publisher != null && !this.publisher.isEmpty();
1285    }
1286
1287    /**
1288     * @param value {@link #publisher} (The name of the individual or organization that published the search parameter.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
1289     */
1290    public SearchParameter setPublisherElement(StringType value) { 
1291      this.publisher = value;
1292      return this;
1293    }
1294
1295    /**
1296     * @return The name of the individual or organization that published the search parameter.
1297     */
1298    public String getPublisher() { 
1299      return this.publisher == null ? null : this.publisher.getValue();
1300    }
1301
1302    /**
1303     * @param value The name of the individual or organization that published the search parameter.
1304     */
1305    public SearchParameter setPublisher(String value) { 
1306      if (Utilities.noString(value))
1307        this.publisher = null;
1308      else {
1309        if (this.publisher == null)
1310          this.publisher = new StringType();
1311        this.publisher.setValue(value);
1312      }
1313      return this;
1314    }
1315
1316    /**
1317     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
1318     */
1319    public List<ContactDetail> getContact() { 
1320      if (this.contact == null)
1321        this.contact = new ArrayList<ContactDetail>();
1322      return this.contact;
1323    }
1324
1325    /**
1326     * @return Returns a reference to <code>this</code> for easy method chaining
1327     */
1328    public SearchParameter setContact(List<ContactDetail> theContact) { 
1329      this.contact = theContact;
1330      return this;
1331    }
1332
1333    public boolean hasContact() { 
1334      if (this.contact == null)
1335        return false;
1336      for (ContactDetail item : this.contact)
1337        if (!item.isEmpty())
1338          return true;
1339      return false;
1340    }
1341
1342    public ContactDetail addContact() { //3
1343      ContactDetail t = new ContactDetail();
1344      if (this.contact == null)
1345        this.contact = new ArrayList<ContactDetail>();
1346      this.contact.add(t);
1347      return t;
1348    }
1349
1350    public SearchParameter addContact(ContactDetail t) { //3
1351      if (t == null)
1352        return this;
1353      if (this.contact == null)
1354        this.contact = new ArrayList<ContactDetail>();
1355      this.contact.add(t);
1356      return this;
1357    }
1358
1359    /**
1360     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist
1361     */
1362    public ContactDetail getContactFirstRep() { 
1363      if (getContact().isEmpty()) {
1364        addContact();
1365      }
1366      return getContact().get(0);
1367    }
1368
1369    /**
1370     * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.)
1371     */
1372    public List<UsageContext> getUseContext() { 
1373      if (this.useContext == null)
1374        this.useContext = new ArrayList<UsageContext>();
1375      return this.useContext;
1376    }
1377
1378    /**
1379     * @return Returns a reference to <code>this</code> for easy method chaining
1380     */
1381    public SearchParameter setUseContext(List<UsageContext> theUseContext) { 
1382      this.useContext = theUseContext;
1383      return this;
1384    }
1385
1386    public boolean hasUseContext() { 
1387      if (this.useContext == null)
1388        return false;
1389      for (UsageContext item : this.useContext)
1390        if (!item.isEmpty())
1391          return true;
1392      return false;
1393    }
1394
1395    public UsageContext addUseContext() { //3
1396      UsageContext t = new UsageContext();
1397      if (this.useContext == null)
1398        this.useContext = new ArrayList<UsageContext>();
1399      this.useContext.add(t);
1400      return t;
1401    }
1402
1403    public SearchParameter addUseContext(UsageContext t) { //3
1404      if (t == null)
1405        return this;
1406      if (this.useContext == null)
1407        this.useContext = new ArrayList<UsageContext>();
1408      this.useContext.add(t);
1409      return this;
1410    }
1411
1412    /**
1413     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist
1414     */
1415    public UsageContext getUseContextFirstRep() { 
1416      if (getUseContext().isEmpty()) {
1417        addUseContext();
1418      }
1419      return getUseContext().get(0);
1420    }
1421
1422    /**
1423     * @return {@link #jurisdiction} (A legal or geographic region in which the search parameter is intended to be used.)
1424     */
1425    public List<CodeableConcept> getJurisdiction() { 
1426      if (this.jurisdiction == null)
1427        this.jurisdiction = new ArrayList<CodeableConcept>();
1428      return this.jurisdiction;
1429    }
1430
1431    /**
1432     * @return Returns a reference to <code>this</code> for easy method chaining
1433     */
1434    public SearchParameter setJurisdiction(List<CodeableConcept> theJurisdiction) { 
1435      this.jurisdiction = theJurisdiction;
1436      return this;
1437    }
1438
1439    public boolean hasJurisdiction() { 
1440      if (this.jurisdiction == null)
1441        return false;
1442      for (CodeableConcept item : this.jurisdiction)
1443        if (!item.isEmpty())
1444          return true;
1445      return false;
1446    }
1447
1448    public CodeableConcept addJurisdiction() { //3
1449      CodeableConcept t = new CodeableConcept();
1450      if (this.jurisdiction == null)
1451        this.jurisdiction = new ArrayList<CodeableConcept>();
1452      this.jurisdiction.add(t);
1453      return t;
1454    }
1455
1456    public SearchParameter addJurisdiction(CodeableConcept t) { //3
1457      if (t == null)
1458        return this;
1459      if (this.jurisdiction == null)
1460        this.jurisdiction = new ArrayList<CodeableConcept>();
1461      this.jurisdiction.add(t);
1462      return this;
1463    }
1464
1465    /**
1466     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist
1467     */
1468    public CodeableConcept getJurisdictionFirstRep() { 
1469      if (getJurisdiction().isEmpty()) {
1470        addJurisdiction();
1471      }
1472      return getJurisdiction().get(0);
1473    }
1474
1475    /**
1476     * @return {@link #purpose} (Explaination of why this search parameter 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
1477     */
1478    public MarkdownType getPurposeElement() { 
1479      if (this.purpose == null)
1480        if (Configuration.errorOnAutoCreate())
1481          throw new Error("Attempt to auto-create SearchParameter.purpose");
1482        else if (Configuration.doAutoCreate())
1483          this.purpose = new MarkdownType(); // bb
1484      return this.purpose;
1485    }
1486
1487    public boolean hasPurposeElement() { 
1488      return this.purpose != null && !this.purpose.isEmpty();
1489    }
1490
1491    public boolean hasPurpose() { 
1492      return this.purpose != null && !this.purpose.isEmpty();
1493    }
1494
1495    /**
1496     * @param value {@link #purpose} (Explaination of why this search parameter 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
1497     */
1498    public SearchParameter setPurposeElement(MarkdownType value) { 
1499      this.purpose = value;
1500      return this;
1501    }
1502
1503    /**
1504     * @return Explaination of why this search parameter is needed and why it has been designed as it has.
1505     */
1506    public String getPurpose() { 
1507      return this.purpose == null ? null : this.purpose.getValue();
1508    }
1509
1510    /**
1511     * @param value Explaination of why this search parameter is needed and why it has been designed as it has.
1512     */
1513    public SearchParameter setPurpose(String value) { 
1514      if (value == null)
1515        this.purpose = null;
1516      else {
1517        if (this.purpose == null)
1518          this.purpose = new MarkdownType();
1519        this.purpose.setValue(value);
1520      }
1521      return this;
1522    }
1523
1524    /**
1525     * @return {@link #code} (The code used in the URL or the parameter name in a parameters resource for this search parameter.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1526     */
1527    public CodeType getCodeElement() { 
1528      if (this.code == null)
1529        if (Configuration.errorOnAutoCreate())
1530          throw new Error("Attempt to auto-create SearchParameter.code");
1531        else if (Configuration.doAutoCreate())
1532          this.code = new CodeType(); // bb
1533      return this.code;
1534    }
1535
1536    public boolean hasCodeElement() { 
1537      return this.code != null && !this.code.isEmpty();
1538    }
1539
1540    public boolean hasCode() { 
1541      return this.code != null && !this.code.isEmpty();
1542    }
1543
1544    /**
1545     * @param value {@link #code} (The code used in the URL or the parameter name in a parameters resource for this search parameter.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1546     */
1547    public SearchParameter setCodeElement(CodeType value) { 
1548      this.code = value;
1549      return this;
1550    }
1551
1552    /**
1553     * @return The code used in the URL or the parameter name in a parameters resource for this search parameter.
1554     */
1555    public String getCode() { 
1556      return this.code == null ? null : this.code.getValue();
1557    }
1558
1559    /**
1560     * @param value The code used in the URL or the parameter name in a parameters resource for this search parameter.
1561     */
1562    public SearchParameter setCode(String value) { 
1563        if (this.code == null)
1564          this.code = new CodeType();
1565        this.code.setValue(value);
1566      return this;
1567    }
1568
1569    /**
1570     * @return {@link #base} (The base resource type(s) that this search parameter can be used against.)
1571     */
1572    public List<CodeType> getBase() { 
1573      if (this.base == null)
1574        this.base = new ArrayList<CodeType>();
1575      return this.base;
1576    }
1577
1578    /**
1579     * @return Returns a reference to <code>this</code> for easy method chaining
1580     */
1581    public SearchParameter setBase(List<CodeType> theBase) { 
1582      this.base = theBase;
1583      return this;
1584    }
1585
1586    public boolean hasBase() { 
1587      if (this.base == null)
1588        return false;
1589      for (CodeType item : this.base)
1590        if (!item.isEmpty())
1591          return true;
1592      return false;
1593    }
1594
1595    /**
1596     * @return {@link #base} (The base resource type(s) that this search parameter can be used against.)
1597     */
1598    public CodeType addBaseElement() {//2 
1599      CodeType t = new CodeType();
1600      if (this.base == null)
1601        this.base = new ArrayList<CodeType>();
1602      this.base.add(t);
1603      return t;
1604    }
1605
1606    /**
1607     * @param value {@link #base} (The base resource type(s) that this search parameter can be used against.)
1608     */
1609    public SearchParameter addBase(String value) { //1
1610      CodeType t = new CodeType();
1611      t.setValue(value);
1612      if (this.base == null)
1613        this.base = new ArrayList<CodeType>();
1614      this.base.add(t);
1615      return this;
1616    }
1617
1618    /**
1619     * @param value {@link #base} (The base resource type(s) that this search parameter can be used against.)
1620     */
1621    public boolean hasBase(String value) { 
1622      if (this.base == null)
1623        return false;
1624      for (CodeType v : this.base)
1625        if (v.getValue().equals(value)) // code
1626          return true;
1627      return false;
1628    }
1629
1630    /**
1631     * @return {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1632     */
1633    public Enumeration<SearchParamType> getTypeElement() { 
1634      if (this.type == null)
1635        if (Configuration.errorOnAutoCreate())
1636          throw new Error("Attempt to auto-create SearchParameter.type");
1637        else if (Configuration.doAutoCreate())
1638          this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); // bb
1639      return this.type;
1640    }
1641
1642    public boolean hasTypeElement() { 
1643      return this.type != null && !this.type.isEmpty();
1644    }
1645
1646    public boolean hasType() { 
1647      return this.type != null && !this.type.isEmpty();
1648    }
1649
1650    /**
1651     * @param value {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1652     */
1653    public SearchParameter setTypeElement(Enumeration<SearchParamType> value) { 
1654      this.type = value;
1655      return this;
1656    }
1657
1658    /**
1659     * @return The type of value a search parameter refers to, and how the content is interpreted.
1660     */
1661    public SearchParamType getType() { 
1662      return this.type == null ? null : this.type.getValue();
1663    }
1664
1665    /**
1666     * @param value The type of value a search parameter refers to, and how the content is interpreted.
1667     */
1668    public SearchParameter setType(SearchParamType value) { 
1669        if (this.type == null)
1670          this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory());
1671        this.type.setValue(value);
1672      return this;
1673    }
1674
1675    /**
1676     * @return {@link #derivedFrom} (Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.). This is the underlying object with id, value and extensions. The accessor "getDerivedFrom" gives direct access to the value
1677     */
1678    public UriType getDerivedFromElement() { 
1679      if (this.derivedFrom == null)
1680        if (Configuration.errorOnAutoCreate())
1681          throw new Error("Attempt to auto-create SearchParameter.derivedFrom");
1682        else if (Configuration.doAutoCreate())
1683          this.derivedFrom = new UriType(); // bb
1684      return this.derivedFrom;
1685    }
1686
1687    public boolean hasDerivedFromElement() { 
1688      return this.derivedFrom != null && !this.derivedFrom.isEmpty();
1689    }
1690
1691    public boolean hasDerivedFrom() { 
1692      return this.derivedFrom != null && !this.derivedFrom.isEmpty();
1693    }
1694
1695    /**
1696     * @param value {@link #derivedFrom} (Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.). This is the underlying object with id, value and extensions. The accessor "getDerivedFrom" gives direct access to the value
1697     */
1698    public SearchParameter setDerivedFromElement(UriType value) { 
1699      this.derivedFrom = value;
1700      return this;
1701    }
1702
1703    /**
1704     * @return Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.
1705     */
1706    public String getDerivedFrom() { 
1707      return this.derivedFrom == null ? null : this.derivedFrom.getValue();
1708    }
1709
1710    /**
1711     * @param value Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.
1712     */
1713    public SearchParameter setDerivedFrom(String value) { 
1714      if (Utilities.noString(value))
1715        this.derivedFrom = null;
1716      else {
1717        if (this.derivedFrom == null)
1718          this.derivedFrom = new UriType();
1719        this.derivedFrom.setValue(value);
1720      }
1721      return this;
1722    }
1723
1724    /**
1725     * @return {@link #description} (A free text natural language description of the search parameter from a consumer's perspective. and how it used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1726     */
1727    public MarkdownType getDescriptionElement() { 
1728      if (this.description == null)
1729        if (Configuration.errorOnAutoCreate())
1730          throw new Error("Attempt to auto-create SearchParameter.description");
1731        else if (Configuration.doAutoCreate())
1732          this.description = new MarkdownType(); // bb
1733      return this.description;
1734    }
1735
1736    public boolean hasDescriptionElement() { 
1737      return this.description != null && !this.description.isEmpty();
1738    }
1739
1740    public boolean hasDescription() { 
1741      return this.description != null && !this.description.isEmpty();
1742    }
1743
1744    /**
1745     * @param value {@link #description} (A free text natural language description of the search parameter from a consumer's perspective. and how it used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1746     */
1747    public SearchParameter setDescriptionElement(MarkdownType value) { 
1748      this.description = value;
1749      return this;
1750    }
1751
1752    /**
1753     * @return A free text natural language description of the search parameter from a consumer's perspective. and how it used.
1754     */
1755    public String getDescription() { 
1756      return this.description == null ? null : this.description.getValue();
1757    }
1758
1759    /**
1760     * @param value A free text natural language description of the search parameter from a consumer's perspective. and how it used.
1761     */
1762    public SearchParameter setDescription(String value) { 
1763        if (this.description == null)
1764          this.description = new MarkdownType();
1765        this.description.setValue(value);
1766      return this;
1767    }
1768
1769    /**
1770     * @return {@link #expression} (A FHIRPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
1771     */
1772    public StringType getExpressionElement() { 
1773      if (this.expression == null)
1774        if (Configuration.errorOnAutoCreate())
1775          throw new Error("Attempt to auto-create SearchParameter.expression");
1776        else if (Configuration.doAutoCreate())
1777          this.expression = new StringType(); // bb
1778      return this.expression;
1779    }
1780
1781    public boolean hasExpressionElement() { 
1782      return this.expression != null && !this.expression.isEmpty();
1783    }
1784
1785    public boolean hasExpression() { 
1786      return this.expression != null && !this.expression.isEmpty();
1787    }
1788
1789    /**
1790     * @param value {@link #expression} (A FHIRPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
1791     */
1792    public SearchParameter setExpressionElement(StringType value) { 
1793      this.expression = value;
1794      return this;
1795    }
1796
1797    /**
1798     * @return A FHIRPath expression that returns a set of elements for the search parameter.
1799     */
1800    public String getExpression() { 
1801      return this.expression == null ? null : this.expression.getValue();
1802    }
1803
1804    /**
1805     * @param value A FHIRPath expression that returns a set of elements for the search parameter.
1806     */
1807    public SearchParameter setExpression(String value) { 
1808      if (Utilities.noString(value))
1809        this.expression = null;
1810      else {
1811        if (this.expression == null)
1812          this.expression = new StringType();
1813        this.expression.setValue(value);
1814      }
1815      return this;
1816    }
1817
1818    /**
1819     * @return {@link #xpath} (An XPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value
1820     */
1821    public StringType getXpathElement() { 
1822      if (this.xpath == null)
1823        if (Configuration.errorOnAutoCreate())
1824          throw new Error("Attempt to auto-create SearchParameter.xpath");
1825        else if (Configuration.doAutoCreate())
1826          this.xpath = new StringType(); // bb
1827      return this.xpath;
1828    }
1829
1830    public boolean hasXpathElement() { 
1831      return this.xpath != null && !this.xpath.isEmpty();
1832    }
1833
1834    public boolean hasXpath() { 
1835      return this.xpath != null && !this.xpath.isEmpty();
1836    }
1837
1838    /**
1839     * @param value {@link #xpath} (An XPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value
1840     */
1841    public SearchParameter setXpathElement(StringType value) { 
1842      this.xpath = value;
1843      return this;
1844    }
1845
1846    /**
1847     * @return An XPath expression that returns a set of elements for the search parameter.
1848     */
1849    public String getXpath() { 
1850      return this.xpath == null ? null : this.xpath.getValue();
1851    }
1852
1853    /**
1854     * @param value An XPath expression that returns a set of elements for the search parameter.
1855     */
1856    public SearchParameter setXpath(String value) { 
1857      if (Utilities.noString(value))
1858        this.xpath = null;
1859      else {
1860        if (this.xpath == null)
1861          this.xpath = new StringType();
1862        this.xpath.setValue(value);
1863      }
1864      return this;
1865    }
1866
1867    /**
1868     * @return {@link #xpathUsage} (How the search parameter relates to the set of elements returned by evaluating the xpath query.). This is the underlying object with id, value and extensions. The accessor "getXpathUsage" gives direct access to the value
1869     */
1870    public Enumeration<XPathUsageType> getXpathUsageElement() { 
1871      if (this.xpathUsage == null)
1872        if (Configuration.errorOnAutoCreate())
1873          throw new Error("Attempt to auto-create SearchParameter.xpathUsage");
1874        else if (Configuration.doAutoCreate())
1875          this.xpathUsage = new Enumeration<XPathUsageType>(new XPathUsageTypeEnumFactory()); // bb
1876      return this.xpathUsage;
1877    }
1878
1879    public boolean hasXpathUsageElement() { 
1880      return this.xpathUsage != null && !this.xpathUsage.isEmpty();
1881    }
1882
1883    public boolean hasXpathUsage() { 
1884      return this.xpathUsage != null && !this.xpathUsage.isEmpty();
1885    }
1886
1887    /**
1888     * @param value {@link #xpathUsage} (How the search parameter relates to the set of elements returned by evaluating the xpath query.). This is the underlying object with id, value and extensions. The accessor "getXpathUsage" gives direct access to the value
1889     */
1890    public SearchParameter setXpathUsageElement(Enumeration<XPathUsageType> value) { 
1891      this.xpathUsage = value;
1892      return this;
1893    }
1894
1895    /**
1896     * @return How the search parameter relates to the set of elements returned by evaluating the xpath query.
1897     */
1898    public XPathUsageType getXpathUsage() { 
1899      return this.xpathUsage == null ? null : this.xpathUsage.getValue();
1900    }
1901
1902    /**
1903     * @param value How the search parameter relates to the set of elements returned by evaluating the xpath query.
1904     */
1905    public SearchParameter setXpathUsage(XPathUsageType value) { 
1906      if (value == null)
1907        this.xpathUsage = null;
1908      else {
1909        if (this.xpathUsage == null)
1910          this.xpathUsage = new Enumeration<XPathUsageType>(new XPathUsageTypeEnumFactory());
1911        this.xpathUsage.setValue(value);
1912      }
1913      return this;
1914    }
1915
1916    /**
1917     * @return {@link #target} (Types of resource (if a resource is referenced).)
1918     */
1919    public List<CodeType> getTarget() { 
1920      if (this.target == null)
1921        this.target = new ArrayList<CodeType>();
1922      return this.target;
1923    }
1924
1925    /**
1926     * @return Returns a reference to <code>this</code> for easy method chaining
1927     */
1928    public SearchParameter setTarget(List<CodeType> theTarget) { 
1929      this.target = theTarget;
1930      return this;
1931    }
1932
1933    public boolean hasTarget() { 
1934      if (this.target == null)
1935        return false;
1936      for (CodeType item : this.target)
1937        if (!item.isEmpty())
1938          return true;
1939      return false;
1940    }
1941
1942    /**
1943     * @return {@link #target} (Types of resource (if a resource is referenced).)
1944     */
1945    public CodeType addTargetElement() {//2 
1946      CodeType t = new CodeType();
1947      if (this.target == null)
1948        this.target = new ArrayList<CodeType>();
1949      this.target.add(t);
1950      return t;
1951    }
1952
1953    /**
1954     * @param value {@link #target} (Types of resource (if a resource is referenced).)
1955     */
1956    public SearchParameter addTarget(String value) { //1
1957      CodeType t = new CodeType();
1958      t.setValue(value);
1959      if (this.target == null)
1960        this.target = new ArrayList<CodeType>();
1961      this.target.add(t);
1962      return this;
1963    }
1964
1965    /**
1966     * @param value {@link #target} (Types of resource (if a resource is referenced).)
1967     */
1968    public boolean hasTarget(String value) { 
1969      if (this.target == null)
1970        return false;
1971      for (CodeType v : this.target)
1972        if (v.getValue().equals(value)) // code
1973          return true;
1974      return false;
1975    }
1976
1977    /**
1978     * @return {@link #comparator} (Comparators supported for the search parameter.)
1979     */
1980    public List<Enumeration<SearchComparator>> getComparator() { 
1981      if (this.comparator == null)
1982        this.comparator = new ArrayList<Enumeration<SearchComparator>>();
1983      return this.comparator;
1984    }
1985
1986    /**
1987     * @return Returns a reference to <code>this</code> for easy method chaining
1988     */
1989    public SearchParameter setComparator(List<Enumeration<SearchComparator>> theComparator) { 
1990      this.comparator = theComparator;
1991      return this;
1992    }
1993
1994    public boolean hasComparator() { 
1995      if (this.comparator == null)
1996        return false;
1997      for (Enumeration<SearchComparator> item : this.comparator)
1998        if (!item.isEmpty())
1999          return true;
2000      return false;
2001    }
2002
2003    /**
2004     * @return {@link #comparator} (Comparators supported for the search parameter.)
2005     */
2006    public Enumeration<SearchComparator> addComparatorElement() {//2 
2007      Enumeration<SearchComparator> t = new Enumeration<SearchComparator>(new SearchComparatorEnumFactory());
2008      if (this.comparator == null)
2009        this.comparator = new ArrayList<Enumeration<SearchComparator>>();
2010      this.comparator.add(t);
2011      return t;
2012    }
2013
2014    /**
2015     * @param value {@link #comparator} (Comparators supported for the search parameter.)
2016     */
2017    public SearchParameter addComparator(SearchComparator value) { //1
2018      Enumeration<SearchComparator> t = new Enumeration<SearchComparator>(new SearchComparatorEnumFactory());
2019      t.setValue(value);
2020      if (this.comparator == null)
2021        this.comparator = new ArrayList<Enumeration<SearchComparator>>();
2022      this.comparator.add(t);
2023      return this;
2024    }
2025
2026    /**
2027     * @param value {@link #comparator} (Comparators supported for the search parameter.)
2028     */
2029    public boolean hasComparator(SearchComparator value) { 
2030      if (this.comparator == null)
2031        return false;
2032      for (Enumeration<SearchComparator> v : this.comparator)
2033        if (v.getValue().equals(value)) // code
2034          return true;
2035      return false;
2036    }
2037
2038    /**
2039     * @return {@link #modifier} (A modifier supported for the search parameter.)
2040     */
2041    public List<Enumeration<SearchModifierCode>> getModifier() { 
2042      if (this.modifier == null)
2043        this.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2044      return this.modifier;
2045    }
2046
2047    /**
2048     * @return Returns a reference to <code>this</code> for easy method chaining
2049     */
2050    public SearchParameter setModifier(List<Enumeration<SearchModifierCode>> theModifier) { 
2051      this.modifier = theModifier;
2052      return this;
2053    }
2054
2055    public boolean hasModifier() { 
2056      if (this.modifier == null)
2057        return false;
2058      for (Enumeration<SearchModifierCode> item : this.modifier)
2059        if (!item.isEmpty())
2060          return true;
2061      return false;
2062    }
2063
2064    /**
2065     * @return {@link #modifier} (A modifier supported for the search parameter.)
2066     */
2067    public Enumeration<SearchModifierCode> addModifierElement() {//2 
2068      Enumeration<SearchModifierCode> t = new Enumeration<SearchModifierCode>(new SearchModifierCodeEnumFactory());
2069      if (this.modifier == null)
2070        this.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2071      this.modifier.add(t);
2072      return t;
2073    }
2074
2075    /**
2076     * @param value {@link #modifier} (A modifier supported for the search parameter.)
2077     */
2078    public SearchParameter addModifier(SearchModifierCode value) { //1
2079      Enumeration<SearchModifierCode> t = new Enumeration<SearchModifierCode>(new SearchModifierCodeEnumFactory());
2080      t.setValue(value);
2081      if (this.modifier == null)
2082        this.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2083      this.modifier.add(t);
2084      return this;
2085    }
2086
2087    /**
2088     * @param value {@link #modifier} (A modifier supported for the search parameter.)
2089     */
2090    public boolean hasModifier(SearchModifierCode value) { 
2091      if (this.modifier == null)
2092        return false;
2093      for (Enumeration<SearchModifierCode> v : this.modifier)
2094        if (v.getValue().equals(value)) // code
2095          return true;
2096      return false;
2097    }
2098
2099    /**
2100     * @return {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2101     */
2102    public List<StringType> getChain() { 
2103      if (this.chain == null)
2104        this.chain = new ArrayList<StringType>();
2105      return this.chain;
2106    }
2107
2108    /**
2109     * @return Returns a reference to <code>this</code> for easy method chaining
2110     */
2111    public SearchParameter setChain(List<StringType> theChain) { 
2112      this.chain = theChain;
2113      return this;
2114    }
2115
2116    public boolean hasChain() { 
2117      if (this.chain == null)
2118        return false;
2119      for (StringType item : this.chain)
2120        if (!item.isEmpty())
2121          return true;
2122      return false;
2123    }
2124
2125    /**
2126     * @return {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2127     */
2128    public StringType addChainElement() {//2 
2129      StringType t = new StringType();
2130      if (this.chain == null)
2131        this.chain = new ArrayList<StringType>();
2132      this.chain.add(t);
2133      return t;
2134    }
2135
2136    /**
2137     * @param value {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2138     */
2139    public SearchParameter addChain(String value) { //1
2140      StringType t = new StringType();
2141      t.setValue(value);
2142      if (this.chain == null)
2143        this.chain = new ArrayList<StringType>();
2144      this.chain.add(t);
2145      return this;
2146    }
2147
2148    /**
2149     * @param value {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2150     */
2151    public boolean hasChain(String value) { 
2152      if (this.chain == null)
2153        return false;
2154      for (StringType v : this.chain)
2155        if (v.getValue().equals(value)) // string
2156          return true;
2157      return false;
2158    }
2159
2160    /**
2161     * @return {@link #component} (Used to define the parts of a composite search parameter.)
2162     */
2163    public List<SearchParameterComponentComponent> getComponent() { 
2164      if (this.component == null)
2165        this.component = new ArrayList<SearchParameterComponentComponent>();
2166      return this.component;
2167    }
2168
2169    /**
2170     * @return Returns a reference to <code>this</code> for easy method chaining
2171     */
2172    public SearchParameter setComponent(List<SearchParameterComponentComponent> theComponent) { 
2173      this.component = theComponent;
2174      return this;
2175    }
2176
2177    public boolean hasComponent() { 
2178      if (this.component == null)
2179        return false;
2180      for (SearchParameterComponentComponent item : this.component)
2181        if (!item.isEmpty())
2182          return true;
2183      return false;
2184    }
2185
2186    public SearchParameterComponentComponent addComponent() { //3
2187      SearchParameterComponentComponent t = new SearchParameterComponentComponent();
2188      if (this.component == null)
2189        this.component = new ArrayList<SearchParameterComponentComponent>();
2190      this.component.add(t);
2191      return t;
2192    }
2193
2194    public SearchParameter addComponent(SearchParameterComponentComponent t) { //3
2195      if (t == null)
2196        return this;
2197      if (this.component == null)
2198        this.component = new ArrayList<SearchParameterComponentComponent>();
2199      this.component.add(t);
2200      return this;
2201    }
2202
2203    /**
2204     * @return The first repetition of repeating field {@link #component}, creating it if it does not already exist
2205     */
2206    public SearchParameterComponentComponent getComponentFirstRep() { 
2207      if (getComponent().isEmpty()) {
2208        addComponent();
2209      }
2210      return getComponent().get(0);
2211    }
2212
2213      protected void listChildren(List<Property> children) {
2214        super.listChildren(children);
2215        children.add(new Property("url", "uri", "An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url));
2216        children.add(new Property("version", "string", "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter 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));
2217        children.add(new Property("name", "string", "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
2218        children.add(new Property("status", "code", "The status of this search parameter. Enables tracking the life-cycle of the content.", 0, 1, status));
2219        children.add(new Property("experimental", "boolean", "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental));
2220        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the search parameter was published. The date must change if and 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 search parameter changes.", 0, 1, date));
2221        children.add(new Property("publisher", "string", "The name of the individual or organization that published the search parameter.", 0, 1, publisher));
2222        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));
2223        children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
2224        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the search parameter is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
2225        children.add(new Property("purpose", "markdown", "Explaination of why this search parameter is needed and why it has been designed as it has.", 0, 1, purpose));
2226        children.add(new Property("code", "code", "The code used in the URL or the parameter name in a parameters resource for this search parameter.", 0, 1, code));
2227        children.add(new Property("base", "code", "The base resource type(s) that this search parameter can be used against.", 0, java.lang.Integer.MAX_VALUE, base));
2228        children.add(new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type));
2229        children.add(new Property("derivedFrom", "uri", "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.", 0, 1, derivedFrom));
2230        children.add(new Property("description", "markdown", "A free text natural language description of the search parameter from a consumer's perspective. and how it used.", 0, 1, description));
2231        children.add(new Property("expression", "string", "A FHIRPath expression that returns a set of elements for the search parameter.", 0, 1, expression));
2232        children.add(new Property("xpath", "string", "An XPath expression that returns a set of elements for the search parameter.", 0, 1, xpath));
2233        children.add(new Property("xpathUsage", "code", "How the search parameter relates to the set of elements returned by evaluating the xpath query.", 0, 1, xpathUsage));
2234        children.add(new Property("target", "code", "Types of resource (if a resource is referenced).", 0, java.lang.Integer.MAX_VALUE, target));
2235        children.add(new Property("comparator", "code", "Comparators supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, comparator));
2236        children.add(new Property("modifier", "code", "A modifier supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, modifier));
2237        children.add(new Property("chain", "string", "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.", 0, java.lang.Integer.MAX_VALUE, chain));
2238        children.add(new Property("component", "", "Used to define the parts of a composite search parameter.", 0, java.lang.Integer.MAX_VALUE, component));
2239      }
2240
2241      @Override
2242      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2243        switch (_hash) {
2244        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url);
2245        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter 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);
2246        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
2247        case -892481550: /*status*/  return new Property("status", "code", "The status of this search parameter. Enables tracking the life-cycle of the content.", 0, 1, status);
2248        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental);
2249        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the search parameter was published. The date must change if and 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 search parameter changes.", 0, 1, date);
2250        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the individual or organization that published the search parameter.", 0, 1, publisher);
2251        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);
2252        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 terms may be used to assist with indexing and searching for appropriate search parameter instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
2253        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the search parameter is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
2254        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explaination of why this search parameter is needed and why it has been designed as it has.", 0, 1, purpose);
2255        case 3059181: /*code*/  return new Property("code", "code", "The code used in the URL or the parameter name in a parameters resource for this search parameter.", 0, 1, code);
2256        case 3016401: /*base*/  return new Property("base", "code", "The base resource type(s) that this search parameter can be used against.", 0, java.lang.Integer.MAX_VALUE, base);
2257        case 3575610: /*type*/  return new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type);
2258        case 1077922663: /*derivedFrom*/  return new Property("derivedFrom", "uri", "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.", 0, 1, derivedFrom);
2259        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the search parameter from a consumer's perspective. and how it used.", 0, 1, description);
2260        case -1795452264: /*expression*/  return new Property("expression", "string", "A FHIRPath expression that returns a set of elements for the search parameter.", 0, 1, expression);
2261        case 114256029: /*xpath*/  return new Property("xpath", "string", "An XPath expression that returns a set of elements for the search parameter.", 0, 1, xpath);
2262        case 1801322244: /*xpathUsage*/  return new Property("xpathUsage", "code", "How the search parameter relates to the set of elements returned by evaluating the xpath query.", 0, 1, xpathUsage);
2263        case -880905839: /*target*/  return new Property("target", "code", "Types of resource (if a resource is referenced).", 0, java.lang.Integer.MAX_VALUE, target);
2264        case -844673834: /*comparator*/  return new Property("comparator", "code", "Comparators supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, comparator);
2265        case -615513385: /*modifier*/  return new Property("modifier", "code", "A modifier supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, modifier);
2266        case 94623425: /*chain*/  return new Property("chain", "string", "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.", 0, java.lang.Integer.MAX_VALUE, chain);
2267        case -1399907075: /*component*/  return new Property("component", "", "Used to define the parts of a composite search parameter.", 0, java.lang.Integer.MAX_VALUE, component);
2268        default: return super.getNamedProperty(_hash, _name, _checkValid);
2269        }
2270
2271      }
2272
2273      @Override
2274      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2275        switch (hash) {
2276        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
2277        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
2278        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
2279        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
2280        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
2281        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
2282        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
2283        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
2284        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
2285        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
2286        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
2287        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType
2288        case 3016401: /*base*/ return this.base == null ? new Base[0] : this.base.toArray(new Base[this.base.size()]); // CodeType
2289        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SearchParamType>
2290        case 1077922663: /*derivedFrom*/ return this.derivedFrom == null ? new Base[0] : new Base[] {this.derivedFrom}; // UriType
2291        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
2292        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
2293        case 114256029: /*xpath*/ return this.xpath == null ? new Base[0] : new Base[] {this.xpath}; // StringType
2294        case 1801322244: /*xpathUsage*/ return this.xpathUsage == null ? new Base[0] : new Base[] {this.xpathUsage}; // Enumeration<XPathUsageType>
2295        case -880905839: /*target*/ return this.target == null ? new Base[0] : this.target.toArray(new Base[this.target.size()]); // CodeType
2296        case -844673834: /*comparator*/ return this.comparator == null ? new Base[0] : this.comparator.toArray(new Base[this.comparator.size()]); // Enumeration<SearchComparator>
2297        case -615513385: /*modifier*/ return this.modifier == null ? new Base[0] : this.modifier.toArray(new Base[this.modifier.size()]); // Enumeration<SearchModifierCode>
2298        case 94623425: /*chain*/ return this.chain == null ? new Base[0] : this.chain.toArray(new Base[this.chain.size()]); // StringType
2299        case -1399907075: /*component*/ return this.component == null ? new Base[0] : this.component.toArray(new Base[this.component.size()]); // SearchParameterComponentComponent
2300        default: return super.getProperty(hash, name, checkValid);
2301        }
2302
2303      }
2304
2305      @Override
2306      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2307        switch (hash) {
2308        case 116079: // url
2309          this.url = castToUri(value); // UriType
2310          return value;
2311        case 351608024: // version
2312          this.version = castToString(value); // StringType
2313          return value;
2314        case 3373707: // name
2315          this.name = castToString(value); // StringType
2316          return value;
2317        case -892481550: // status
2318          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
2319          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
2320          return value;
2321        case -404562712: // experimental
2322          this.experimental = castToBoolean(value); // BooleanType
2323          return value;
2324        case 3076014: // date
2325          this.date = castToDateTime(value); // DateTimeType
2326          return value;
2327        case 1447404028: // publisher
2328          this.publisher = castToString(value); // StringType
2329          return value;
2330        case 951526432: // contact
2331          this.getContact().add(castToContactDetail(value)); // ContactDetail
2332          return value;
2333        case -669707736: // useContext
2334          this.getUseContext().add(castToUsageContext(value)); // UsageContext
2335          return value;
2336        case -507075711: // jurisdiction
2337          this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept
2338          return value;
2339        case -220463842: // purpose
2340          this.purpose = castToMarkdown(value); // MarkdownType
2341          return value;
2342        case 3059181: // code
2343          this.code = castToCode(value); // CodeType
2344          return value;
2345        case 3016401: // base
2346          this.getBase().add(castToCode(value)); // CodeType
2347          return value;
2348        case 3575610: // type
2349          value = new SearchParamTypeEnumFactory().fromType(castToCode(value));
2350          this.type = (Enumeration) value; // Enumeration<SearchParamType>
2351          return value;
2352        case 1077922663: // derivedFrom
2353          this.derivedFrom = castToUri(value); // UriType
2354          return value;
2355        case -1724546052: // description
2356          this.description = castToMarkdown(value); // MarkdownType
2357          return value;
2358        case -1795452264: // expression
2359          this.expression = castToString(value); // StringType
2360          return value;
2361        case 114256029: // xpath
2362          this.xpath = castToString(value); // StringType
2363          return value;
2364        case 1801322244: // xpathUsage
2365          value = new XPathUsageTypeEnumFactory().fromType(castToCode(value));
2366          this.xpathUsage = (Enumeration) value; // Enumeration<XPathUsageType>
2367          return value;
2368        case -880905839: // target
2369          this.getTarget().add(castToCode(value)); // CodeType
2370          return value;
2371        case -844673834: // comparator
2372          value = new SearchComparatorEnumFactory().fromType(castToCode(value));
2373          this.getComparator().add((Enumeration) value); // Enumeration<SearchComparator>
2374          return value;
2375        case -615513385: // modifier
2376          value = new SearchModifierCodeEnumFactory().fromType(castToCode(value));
2377          this.getModifier().add((Enumeration) value); // Enumeration<SearchModifierCode>
2378          return value;
2379        case 94623425: // chain
2380          this.getChain().add(castToString(value)); // StringType
2381          return value;
2382        case -1399907075: // component
2383          this.getComponent().add((SearchParameterComponentComponent) value); // SearchParameterComponentComponent
2384          return value;
2385        default: return super.setProperty(hash, name, value);
2386        }
2387
2388      }
2389
2390      @Override
2391      public Base setProperty(String name, Base value) throws FHIRException {
2392        if (name.equals("url")) {
2393          this.url = castToUri(value); // UriType
2394        } else if (name.equals("version")) {
2395          this.version = castToString(value); // StringType
2396        } else if (name.equals("name")) {
2397          this.name = castToString(value); // StringType
2398        } else if (name.equals("status")) {
2399          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
2400          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
2401        } else if (name.equals("experimental")) {
2402          this.experimental = castToBoolean(value); // BooleanType
2403        } else if (name.equals("date")) {
2404          this.date = castToDateTime(value); // DateTimeType
2405        } else if (name.equals("publisher")) {
2406          this.publisher = castToString(value); // StringType
2407        } else if (name.equals("contact")) {
2408          this.getContact().add(castToContactDetail(value));
2409        } else if (name.equals("useContext")) {
2410          this.getUseContext().add(castToUsageContext(value));
2411        } else if (name.equals("jurisdiction")) {
2412          this.getJurisdiction().add(castToCodeableConcept(value));
2413        } else if (name.equals("purpose")) {
2414          this.purpose = castToMarkdown(value); // MarkdownType
2415        } else if (name.equals("code")) {
2416          this.code = castToCode(value); // CodeType
2417        } else if (name.equals("base")) {
2418          this.getBase().add(castToCode(value));
2419        } else if (name.equals("type")) {
2420          value = new SearchParamTypeEnumFactory().fromType(castToCode(value));
2421          this.type = (Enumeration) value; // Enumeration<SearchParamType>
2422        } else if (name.equals("derivedFrom")) {
2423          this.derivedFrom = castToUri(value); // UriType
2424        } else if (name.equals("description")) {
2425          this.description = castToMarkdown(value); // MarkdownType
2426        } else if (name.equals("expression")) {
2427          this.expression = castToString(value); // StringType
2428        } else if (name.equals("xpath")) {
2429          this.xpath = castToString(value); // StringType
2430        } else if (name.equals("xpathUsage")) {
2431          value = new XPathUsageTypeEnumFactory().fromType(castToCode(value));
2432          this.xpathUsage = (Enumeration) value; // Enumeration<XPathUsageType>
2433        } else if (name.equals("target")) {
2434          this.getTarget().add(castToCode(value));
2435        } else if (name.equals("comparator")) {
2436          value = new SearchComparatorEnumFactory().fromType(castToCode(value));
2437          this.getComparator().add((Enumeration) value);
2438        } else if (name.equals("modifier")) {
2439          value = new SearchModifierCodeEnumFactory().fromType(castToCode(value));
2440          this.getModifier().add((Enumeration) value);
2441        } else if (name.equals("chain")) {
2442          this.getChain().add(castToString(value));
2443        } else if (name.equals("component")) {
2444          this.getComponent().add((SearchParameterComponentComponent) value);
2445        } else
2446          return super.setProperty(name, value);
2447        return value;
2448      }
2449
2450      @Override
2451      public Base makeProperty(int hash, String name) throws FHIRException {
2452        switch (hash) {
2453        case 116079:  return getUrlElement();
2454        case 351608024:  return getVersionElement();
2455        case 3373707:  return getNameElement();
2456        case -892481550:  return getStatusElement();
2457        case -404562712:  return getExperimentalElement();
2458        case 3076014:  return getDateElement();
2459        case 1447404028:  return getPublisherElement();
2460        case 951526432:  return addContact(); 
2461        case -669707736:  return addUseContext(); 
2462        case -507075711:  return addJurisdiction(); 
2463        case -220463842:  return getPurposeElement();
2464        case 3059181:  return getCodeElement();
2465        case 3016401:  return addBaseElement();
2466        case 3575610:  return getTypeElement();
2467        case 1077922663:  return getDerivedFromElement();
2468        case -1724546052:  return getDescriptionElement();
2469        case -1795452264:  return getExpressionElement();
2470        case 114256029:  return getXpathElement();
2471        case 1801322244:  return getXpathUsageElement();
2472        case -880905839:  return addTargetElement();
2473        case -844673834:  return addComparatorElement();
2474        case -615513385:  return addModifierElement();
2475        case 94623425:  return addChainElement();
2476        case -1399907075:  return addComponent(); 
2477        default: return super.makeProperty(hash, name);
2478        }
2479
2480      }
2481
2482      @Override
2483      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2484        switch (hash) {
2485        case 116079: /*url*/ return new String[] {"uri"};
2486        case 351608024: /*version*/ return new String[] {"string"};
2487        case 3373707: /*name*/ return new String[] {"string"};
2488        case -892481550: /*status*/ return new String[] {"code"};
2489        case -404562712: /*experimental*/ return new String[] {"boolean"};
2490        case 3076014: /*date*/ return new String[] {"dateTime"};
2491        case 1447404028: /*publisher*/ return new String[] {"string"};
2492        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
2493        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
2494        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
2495        case -220463842: /*purpose*/ return new String[] {"markdown"};
2496        case 3059181: /*code*/ return new String[] {"code"};
2497        case 3016401: /*base*/ return new String[] {"code"};
2498        case 3575610: /*type*/ return new String[] {"code"};
2499        case 1077922663: /*derivedFrom*/ return new String[] {"uri"};
2500        case -1724546052: /*description*/ return new String[] {"markdown"};
2501        case -1795452264: /*expression*/ return new String[] {"string"};
2502        case 114256029: /*xpath*/ return new String[] {"string"};
2503        case 1801322244: /*xpathUsage*/ return new String[] {"code"};
2504        case -880905839: /*target*/ return new String[] {"code"};
2505        case -844673834: /*comparator*/ return new String[] {"code"};
2506        case -615513385: /*modifier*/ return new String[] {"code"};
2507        case 94623425: /*chain*/ return new String[] {"string"};
2508        case -1399907075: /*component*/ return new String[] {};
2509        default: return super.getTypesForProperty(hash, name);
2510        }
2511
2512      }
2513
2514      @Override
2515      public Base addChild(String name) throws FHIRException {
2516        if (name.equals("url")) {
2517          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.url");
2518        }
2519        else if (name.equals("version")) {
2520          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.version");
2521        }
2522        else if (name.equals("name")) {
2523          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.name");
2524        }
2525        else if (name.equals("status")) {
2526          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.status");
2527        }
2528        else if (name.equals("experimental")) {
2529          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.experimental");
2530        }
2531        else if (name.equals("date")) {
2532          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.date");
2533        }
2534        else if (name.equals("publisher")) {
2535          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.publisher");
2536        }
2537        else if (name.equals("contact")) {
2538          return addContact();
2539        }
2540        else if (name.equals("useContext")) {
2541          return addUseContext();
2542        }
2543        else if (name.equals("jurisdiction")) {
2544          return addJurisdiction();
2545        }
2546        else if (name.equals("purpose")) {
2547          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.purpose");
2548        }
2549        else if (name.equals("code")) {
2550          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.code");
2551        }
2552        else if (name.equals("base")) {
2553          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.base");
2554        }
2555        else if (name.equals("type")) {
2556          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.type");
2557        }
2558        else if (name.equals("derivedFrom")) {
2559          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.derivedFrom");
2560        }
2561        else if (name.equals("description")) {
2562          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.description");
2563        }
2564        else if (name.equals("expression")) {
2565          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.expression");
2566        }
2567        else if (name.equals("xpath")) {
2568          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.xpath");
2569        }
2570        else if (name.equals("xpathUsage")) {
2571          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.xpathUsage");
2572        }
2573        else if (name.equals("target")) {
2574          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.target");
2575        }
2576        else if (name.equals("comparator")) {
2577          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.comparator");
2578        }
2579        else if (name.equals("modifier")) {
2580          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.modifier");
2581        }
2582        else if (name.equals("chain")) {
2583          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.chain");
2584        }
2585        else if (name.equals("component")) {
2586          return addComponent();
2587        }
2588        else
2589          return super.addChild(name);
2590      }
2591
2592  public String fhirType() {
2593    return "SearchParameter";
2594
2595  }
2596
2597      public SearchParameter copy() {
2598        SearchParameter dst = new SearchParameter();
2599        copyValues(dst);
2600        dst.url = url == null ? null : url.copy();
2601        dst.version = version == null ? null : version.copy();
2602        dst.name = name == null ? null : name.copy();
2603        dst.status = status == null ? null : status.copy();
2604        dst.experimental = experimental == null ? null : experimental.copy();
2605        dst.date = date == null ? null : date.copy();
2606        dst.publisher = publisher == null ? null : publisher.copy();
2607        if (contact != null) {
2608          dst.contact = new ArrayList<ContactDetail>();
2609          for (ContactDetail i : contact)
2610            dst.contact.add(i.copy());
2611        };
2612        if (useContext != null) {
2613          dst.useContext = new ArrayList<UsageContext>();
2614          for (UsageContext i : useContext)
2615            dst.useContext.add(i.copy());
2616        };
2617        if (jurisdiction != null) {
2618          dst.jurisdiction = new ArrayList<CodeableConcept>();
2619          for (CodeableConcept i : jurisdiction)
2620            dst.jurisdiction.add(i.copy());
2621        };
2622        dst.purpose = purpose == null ? null : purpose.copy();
2623        dst.code = code == null ? null : code.copy();
2624        if (base != null) {
2625          dst.base = new ArrayList<CodeType>();
2626          for (CodeType i : base)
2627            dst.base.add(i.copy());
2628        };
2629        dst.type = type == null ? null : type.copy();
2630        dst.derivedFrom = derivedFrom == null ? null : derivedFrom.copy();
2631        dst.description = description == null ? null : description.copy();
2632        dst.expression = expression == null ? null : expression.copy();
2633        dst.xpath = xpath == null ? null : xpath.copy();
2634        dst.xpathUsage = xpathUsage == null ? null : xpathUsage.copy();
2635        if (target != null) {
2636          dst.target = new ArrayList<CodeType>();
2637          for (CodeType i : target)
2638            dst.target.add(i.copy());
2639        };
2640        if (comparator != null) {
2641          dst.comparator = new ArrayList<Enumeration<SearchComparator>>();
2642          for (Enumeration<SearchComparator> i : comparator)
2643            dst.comparator.add(i.copy());
2644        };
2645        if (modifier != null) {
2646          dst.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2647          for (Enumeration<SearchModifierCode> i : modifier)
2648            dst.modifier.add(i.copy());
2649        };
2650        if (chain != null) {
2651          dst.chain = new ArrayList<StringType>();
2652          for (StringType i : chain)
2653            dst.chain.add(i.copy());
2654        };
2655        if (component != null) {
2656          dst.component = new ArrayList<SearchParameterComponentComponent>();
2657          for (SearchParameterComponentComponent i : component)
2658            dst.component.add(i.copy());
2659        };
2660        return dst;
2661      }
2662
2663      protected SearchParameter typedCopy() {
2664        return copy();
2665      }
2666
2667      @Override
2668      public boolean equalsDeep(Base other_) {
2669        if (!super.equalsDeep(other_))
2670          return false;
2671        if (!(other_ instanceof SearchParameter))
2672          return false;
2673        SearchParameter o = (SearchParameter) other_;
2674        return compareDeep(purpose, o.purpose, true) && compareDeep(code, o.code, true) && compareDeep(base, o.base, true)
2675           && compareDeep(type, o.type, true) && compareDeep(derivedFrom, o.derivedFrom, true) && compareDeep(expression, o.expression, true)
2676           && compareDeep(xpath, o.xpath, true) && compareDeep(xpathUsage, o.xpathUsage, true) && compareDeep(target, o.target, true)
2677           && compareDeep(comparator, o.comparator, true) && compareDeep(modifier, o.modifier, true) && compareDeep(chain, o.chain, true)
2678           && compareDeep(component, o.component, true);
2679      }
2680
2681      @Override
2682      public boolean equalsShallow(Base other_) {
2683        if (!super.equalsShallow(other_))
2684          return false;
2685        if (!(other_ instanceof SearchParameter))
2686          return false;
2687        SearchParameter o = (SearchParameter) other_;
2688        return compareValues(purpose, o.purpose, true) && compareValues(code, o.code, true) && compareValues(base, o.base, true)
2689           && compareValues(type, o.type, true) && compareValues(derivedFrom, o.derivedFrom, true) && compareValues(expression, o.expression, true)
2690           && compareValues(xpath, o.xpath, true) && compareValues(xpathUsage, o.xpathUsage, true) && compareValues(target, o.target, true)
2691           && compareValues(comparator, o.comparator, true) && compareValues(modifier, o.modifier, true) && compareValues(chain, o.chain, true)
2692          ;
2693      }
2694
2695      public boolean isEmpty() {
2696        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(purpose, code, base, type
2697          , derivedFrom, expression, xpath, xpathUsage, target, comparator, modifier, chain
2698          , component);
2699      }
2700
2701  @Override
2702  public ResourceType getResourceType() {
2703    return ResourceType.SearchParameter;
2704   }
2705
2706 /**
2707   * Search parameter: <b>date</b>
2708   * <p>
2709   * Description: <b>The search parameter publication date</b><br>
2710   * Type: <b>date</b><br>
2711   * Path: <b>SearchParameter.date</b><br>
2712   * </p>
2713   */
2714  @SearchParamDefinition(name="date", path="SearchParameter.date", description="The search parameter publication date", type="date" )
2715  public static final String SP_DATE = "date";
2716 /**
2717   * <b>Fluent Client</b> search parameter constant for <b>date</b>
2718   * <p>
2719   * Description: <b>The search parameter publication date</b><br>
2720   * Type: <b>date</b><br>
2721   * Path: <b>SearchParameter.date</b><br>
2722   * </p>
2723   */
2724  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
2725
2726 /**
2727   * Search parameter: <b>code</b>
2728   * <p>
2729   * Description: <b>Code used in URL</b><br>
2730   * Type: <b>token</b><br>
2731   * Path: <b>SearchParameter.code</b><br>
2732   * </p>
2733   */
2734  @SearchParamDefinition(name="code", path="SearchParameter.code", description="Code used in URL", type="token" )
2735  public static final String SP_CODE = "code";
2736 /**
2737   * <b>Fluent Client</b> search parameter constant for <b>code</b>
2738   * <p>
2739   * Description: <b>Code used in URL</b><br>
2740   * Type: <b>token</b><br>
2741   * Path: <b>SearchParameter.code</b><br>
2742   * </p>
2743   */
2744  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE);
2745
2746 /**
2747   * Search parameter: <b>jurisdiction</b>
2748   * <p>
2749   * Description: <b>Intended jurisdiction for the search parameter</b><br>
2750   * Type: <b>token</b><br>
2751   * Path: <b>SearchParameter.jurisdiction</b><br>
2752   * </p>
2753   */
2754  @SearchParamDefinition(name="jurisdiction", path="SearchParameter.jurisdiction", description="Intended jurisdiction for the search parameter", type="token" )
2755  public static final String SP_JURISDICTION = "jurisdiction";
2756 /**
2757   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
2758   * <p>
2759   * Description: <b>Intended jurisdiction for the search parameter</b><br>
2760   * Type: <b>token</b><br>
2761   * Path: <b>SearchParameter.jurisdiction</b><br>
2762   * </p>
2763   */
2764  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
2765
2766 /**
2767   * Search parameter: <b>description</b>
2768   * <p>
2769   * Description: <b>The description of the search parameter</b><br>
2770   * Type: <b>string</b><br>
2771   * Path: <b>SearchParameter.description</b><br>
2772   * </p>
2773   */
2774  @SearchParamDefinition(name="description", path="SearchParameter.description", description="The description of the search parameter", type="string" )
2775  public static final String SP_DESCRIPTION = "description";
2776 /**
2777   * <b>Fluent Client</b> search parameter constant for <b>description</b>
2778   * <p>
2779   * Description: <b>The description of the search parameter</b><br>
2780   * Type: <b>string</b><br>
2781   * Path: <b>SearchParameter.description</b><br>
2782   * </p>
2783   */
2784  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
2785
2786 /**
2787   * Search parameter: <b>derived-from</b>
2788   * <p>
2789   * Description: <b>Original Definition for the search parameter</b><br>
2790   * Type: <b>uri</b><br>
2791   * Path: <b>SearchParameter.derivedFrom</b><br>
2792   * </p>
2793   */
2794  @SearchParamDefinition(name="derived-from", path="SearchParameter.derivedFrom", description="Original Definition for the search parameter", type="uri" )
2795  public static final String SP_DERIVED_FROM = "derived-from";
2796 /**
2797   * <b>Fluent Client</b> search parameter constant for <b>derived-from</b>
2798   * <p>
2799   * Description: <b>Original Definition for the search parameter</b><br>
2800   * Type: <b>uri</b><br>
2801   * Path: <b>SearchParameter.derivedFrom</b><br>
2802   * </p>
2803   */
2804  public static final ca.uhn.fhir.rest.gclient.UriClientParam DERIVED_FROM = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_DERIVED_FROM);
2805
2806 /**
2807   * Search parameter: <b>type</b>
2808   * <p>
2809   * Description: <b>number | date | string | token | reference | composite | quantity | uri</b><br>
2810   * Type: <b>token</b><br>
2811   * Path: <b>SearchParameter.type</b><br>
2812   * </p>
2813   */
2814  @SearchParamDefinition(name="type", path="SearchParameter.type", description="number | date | string | token | reference | composite | quantity | uri", type="token" )
2815  public static final String SP_TYPE = "type";
2816 /**
2817   * <b>Fluent Client</b> search parameter constant for <b>type</b>
2818   * <p>
2819   * Description: <b>number | date | string | token | reference | composite | quantity | uri</b><br>
2820   * Type: <b>token</b><br>
2821   * Path: <b>SearchParameter.type</b><br>
2822   * </p>
2823   */
2824  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
2825
2826 /**
2827   * Search parameter: <b>version</b>
2828   * <p>
2829   * Description: <b>The business version of the search parameter</b><br>
2830   * Type: <b>token</b><br>
2831   * Path: <b>SearchParameter.version</b><br>
2832   * </p>
2833   */
2834  @SearchParamDefinition(name="version", path="SearchParameter.version", description="The business version of the search parameter", type="token" )
2835  public static final String SP_VERSION = "version";
2836 /**
2837   * <b>Fluent Client</b> search parameter constant for <b>version</b>
2838   * <p>
2839   * Description: <b>The business version of the search parameter</b><br>
2840   * Type: <b>token</b><br>
2841   * Path: <b>SearchParameter.version</b><br>
2842   * </p>
2843   */
2844  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
2845
2846 /**
2847   * Search parameter: <b>url</b>
2848   * <p>
2849   * Description: <b>The uri that identifies the search parameter</b><br>
2850   * Type: <b>uri</b><br>
2851   * Path: <b>SearchParameter.url</b><br>
2852   * </p>
2853   */
2854  @SearchParamDefinition(name="url", path="SearchParameter.url", description="The uri that identifies the search parameter", type="uri" )
2855  public static final String SP_URL = "url";
2856 /**
2857   * <b>Fluent Client</b> search parameter constant for <b>url</b>
2858   * <p>
2859   * Description: <b>The uri that identifies the search parameter</b><br>
2860   * Type: <b>uri</b><br>
2861   * Path: <b>SearchParameter.url</b><br>
2862   * </p>
2863   */
2864  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
2865
2866 /**
2867   * Search parameter: <b>target</b>
2868   * <p>
2869   * Description: <b>Types of resource (if a resource reference)</b><br>
2870   * Type: <b>token</b><br>
2871   * Path: <b>SearchParameter.target</b><br>
2872   * </p>
2873   */
2874  @SearchParamDefinition(name="target", path="SearchParameter.target", description="Types of resource (if a resource reference)", type="token" )
2875  public static final String SP_TARGET = "target";
2876 /**
2877   * <b>Fluent Client</b> search parameter constant for <b>target</b>
2878   * <p>
2879   * Description: <b>Types of resource (if a resource reference)</b><br>
2880   * Type: <b>token</b><br>
2881   * Path: <b>SearchParameter.target</b><br>
2882   * </p>
2883   */
2884  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TARGET = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TARGET);
2885
2886 /**
2887   * Search parameter: <b>component</b>
2888   * <p>
2889   * Description: <b>Defines how the part works</b><br>
2890   * Type: <b>reference</b><br>
2891   * Path: <b>SearchParameter.component.definition</b><br>
2892   * </p>
2893   */
2894  @SearchParamDefinition(name="component", path="SearchParameter.component.definition", description="Defines how the part works", type="reference", target={SearchParameter.class } )
2895  public static final String SP_COMPONENT = "component";
2896 /**
2897   * <b>Fluent Client</b> search parameter constant for <b>component</b>
2898   * <p>
2899   * Description: <b>Defines how the part works</b><br>
2900   * Type: <b>reference</b><br>
2901   * Path: <b>SearchParameter.component.definition</b><br>
2902   * </p>
2903   */
2904  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam COMPONENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_COMPONENT);
2905
2906/**
2907   * Constant for fluent queries to be used to add include statements. Specifies
2908   * the path value of "<b>SearchParameter:component</b>".
2909   */
2910  public static final ca.uhn.fhir.model.api.Include INCLUDE_COMPONENT = new ca.uhn.fhir.model.api.Include("SearchParameter:component").toLocked();
2911
2912 /**
2913   * Search parameter: <b>name</b>
2914   * <p>
2915   * Description: <b>Computationally friendly name of the search parameter</b><br>
2916   * Type: <b>string</b><br>
2917   * Path: <b>SearchParameter.name</b><br>
2918   * </p>
2919   */
2920  @SearchParamDefinition(name="name", path="SearchParameter.name", description="Computationally friendly name of the search parameter", type="string" )
2921  public static final String SP_NAME = "name";
2922 /**
2923   * <b>Fluent Client</b> search parameter constant for <b>name</b>
2924   * <p>
2925   * Description: <b>Computationally friendly name of the search parameter</b><br>
2926   * Type: <b>string</b><br>
2927   * Path: <b>SearchParameter.name</b><br>
2928   * </p>
2929   */
2930  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
2931
2932 /**
2933   * Search parameter: <b>publisher</b>
2934   * <p>
2935   * Description: <b>Name of the publisher of the search parameter</b><br>
2936   * Type: <b>string</b><br>
2937   * Path: <b>SearchParameter.publisher</b><br>
2938   * </p>
2939   */
2940  @SearchParamDefinition(name="publisher", path="SearchParameter.publisher", description="Name of the publisher of the search parameter", type="string" )
2941  public static final String SP_PUBLISHER = "publisher";
2942 /**
2943   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
2944   * <p>
2945   * Description: <b>Name of the publisher of the search parameter</b><br>
2946   * Type: <b>string</b><br>
2947   * Path: <b>SearchParameter.publisher</b><br>
2948   * </p>
2949   */
2950  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
2951
2952 /**
2953   * Search parameter: <b>status</b>
2954   * <p>
2955   * Description: <b>The current status of the search parameter</b><br>
2956   * Type: <b>token</b><br>
2957   * Path: <b>SearchParameter.status</b><br>
2958   * </p>
2959   */
2960  @SearchParamDefinition(name="status", path="SearchParameter.status", description="The current status of the search parameter", type="token" )
2961  public static final String SP_STATUS = "status";
2962 /**
2963   * <b>Fluent Client</b> search parameter constant for <b>status</b>
2964   * <p>
2965   * Description: <b>The current status of the search parameter</b><br>
2966   * Type: <b>token</b><br>
2967   * Path: <b>SearchParameter.status</b><br>
2968   * </p>
2969   */
2970  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
2971
2972 /**
2973   * Search parameter: <b>base</b>
2974   * <p>
2975   * Description: <b>The resource type(s) this search parameter applies to</b><br>
2976   * Type: <b>token</b><br>
2977   * Path: <b>SearchParameter.base</b><br>
2978   * </p>
2979   */
2980  @SearchParamDefinition(name="base", path="SearchParameter.base", description="The resource type(s) this search parameter applies to", type="token" )
2981  public static final String SP_BASE = "base";
2982 /**
2983   * <b>Fluent Client</b> search parameter constant for <b>base</b>
2984   * <p>
2985   * Description: <b>The resource type(s) this search parameter applies to</b><br>
2986   * Type: <b>token</b><br>
2987   * Path: <b>SearchParameter.base</b><br>
2988   * </p>
2989   */
2990  public static final ca.uhn.fhir.rest.gclient.TokenClientParam BASE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_BASE);
2991
2992
2993}
2994